vulkan: Include a copy of vulkan.h and vk_platform.h.
authorRyan C. Gordon <icculus@icculus.org>
Sun, 27 Aug 2017 23:25:12 -0400
changeset 11367e8fc755a89e8
parent 11366 1e4fe1678a00
child 11368 ec36cac7a0b0
vulkan: Include a copy of vulkan.h and vk_platform.h.

Now we can provide Vulkan support in the build even if the build box doesn't
have a Vulkan SDK, since we dynamically link to the library anyhow.
CMakeLists.txt
cmake/sdlchecks.cmake
configure
configure.in
src/video/SDL_vulkan_internal.h
src/video/cocoa/SDL_cocoametalview.m
src/video/khronos/vulkan/vk_platform.h
src/video/khronos/vulkan/vulkan.h
test/testvulkan.c
     1.1 --- a/CMakeLists.txt	Sun Aug 27 19:32:08 2017 -0700
     1.2 +++ b/CMakeLists.txt	Sun Aug 27 23:25:12 2017 -0400
     1.3 @@ -329,10 +329,6 @@
     1.4  set_option(VIDEO_KMSDRM        "Use KMS DRM video driver" ${UNIX_SYS})
     1.5  dep_option(KMSDRM_SHARED       "Dynamically load KMS DRM support" ON "VIDEO_KMSDRM" OFF)
     1.6  
     1.7 -if(VIDEO_VULKAN)
     1.8 -  set(VULKAN_SDK $ENV{VULKAN_SDK} CACHE PATH "Location of Vulkan headers' grandparent, e.g. /foo when headers are in /foo/include/vulkan.")
     1.9 -endif()
    1.10 -
    1.11  # TODO: We should (should we?) respect cmake's ${BUILD_SHARED_LIBS} flag here
    1.12  # The options below are for compatibility to configure's default behaviour.
    1.13  set(SDL_SHARED ${SDL_SHARED_ENABLED_BY_DEFAULT} CACHE BOOL "Build a shared version of the library")
    1.14 @@ -874,8 +870,6 @@
    1.15      if(NOT VULKAN_PASSED_ANDROID_CHECKS)
    1.16        set(VIDEO_VULKAN OFF)
    1.17        message(STATUS "Vulkan doesn't work on this configuration")
    1.18 -    else()
    1.19 -      CheckVulkanHeaders()
    1.20      endif()
    1.21    endif()
    1.22  
    1.23 @@ -1041,8 +1035,6 @@
    1.24      endif()
    1.25  
    1.26      check_include_file("fcitx/frontend.h" HAVE_FCITX_FRONTEND_H)
    1.27 -
    1.28 -    CheckVulkanHeaders()
    1.29    endif()
    1.30  
    1.31    if(INPUT_TSLIB)
    1.32 @@ -1301,8 +1293,6 @@
    1.33        set(SDL_VIDEO_RENDER_OGL_ES2 1)
    1.34        set(HAVE_VIDEO_OPENGLES TRUE)
    1.35      endif()
    1.36 -
    1.37 -    CheckVulkanHeaders()
    1.38    endif()
    1.39  
    1.40    if(SDL_JOYSTICK)
    1.41 @@ -1445,11 +1435,8 @@
    1.42  
    1.43    # Actually load the frameworks at the end so we don't duplicate include.
    1.44    if (VIDEO_VULKAN)
    1.45 -    CheckVulkanHeaders()
    1.46 -    if(HAVE_VULKAN_H)
    1.47 -      find_library(QUARTZCORE QuartzCore)
    1.48 -      list(APPEND EXTRA_LIBS ${QUARTZCORE})
    1.49 -    endif()
    1.50 +    find_library(QUARTZCORE QuartzCore)
    1.51 +    list(APPEND EXTRA_LIBS ${QUARTZCORE})
    1.52    endif()
    1.53    if(SDL_FRAMEWORK_COREVIDEO)
    1.54      find_library(COREVIDEO CoreVideo)
    1.55 @@ -1530,7 +1517,7 @@
    1.56    CheckPTHREAD()
    1.57  endif()
    1.58  
    1.59 -if(VIDEO_VULKAN AND HAVE_VULKAN_H AND (NOT APPLE OR QUARTZCORE))
    1.60 +if(VIDEO_VULKAN AND (NOT APPLE OR QUARTZCORE))
    1.61    set(SDL_VIDEO_VULKAN_SURFACE 1)
    1.62  endif()
    1.63  
     2.1 --- a/cmake/sdlchecks.cmake	Sun Aug 27 19:32:08 2017 -0700
     2.2 +++ b/cmake/sdlchecks.cmake	Sun Aug 27 23:25:12 2017 -0400
     2.3 @@ -1153,25 +1153,6 @@
     2.4    endif(VIDEO_RPI)
     2.5  endmacro(CheckRPI)
     2.6  
     2.7 -macro(CheckVulkanHeaders)
     2.8 -  if(VIDEO_VULKAN)
     2.9 -    # ${VULKAN_SDK} could be unset during the first configure run with
    2.10 -    # cmake-gui resulting in vulkan.h not being found. If it's been
    2.11 -    # subsequently changed, unset is necessary to ensure check is run again.
    2.12 -    unset(HAVE_VULKAN_H CACHE)
    2.13 -    # Prefer ${VULKAN_SDK} header
    2.14 -    set(CMAKE_REQUIRED_INCLUDES "${VULKAN_SDK}/include")
    2.15 -    check_include_file("vulkan/vulkan.h" HAVE_VULKAN_H)
    2.16 -    if(HAVE_VULKAN_H)
    2.17 -      list(APPEND EXTRA_CFLAGS "-I${VULKAN_SDK}/include")
    2.18 -    else()
    2.19 -      # Check system includes.
    2.20 -      unset(HAVE_VULKAN_H CACHE)
    2.21 -      check_include_file("vulkan/vulkan.h" HAVE_VULKAN_H)
    2.22 -    endif()
    2.23 -  endif()
    2.24 -endmacro(CheckVulkanHeaders)
    2.25 -
    2.26  # Requires:
    2.27  # - EGL
    2.28  # - PkgCheckModules
     3.1 --- a/configure	Sun Aug 27 19:32:08 2017 -0700
     3.2 +++ b/configure	Sun Aug 27 23:25:12 2017 -0400
     3.3 @@ -21915,7 +21915,6 @@
     3.4  
     3.5  CheckVulkan()
     3.6  {
     3.7 -    have_vulkan_hdr=no
     3.8      if test x$enable_video = xyes -a x$enable_video_vulkan = xyes; then
     3.9          case "$host" in
    3.10              *-*-androideabi*)
    3.11 @@ -21955,30 +21954,8 @@
    3.12              { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, Vulkan does not work on this configuration." >&5
    3.13  $as_echo "$as_me: WARNING: Sorry, Vulkan does not work on this configuration." >&2;}
    3.14          fi
    3.15 -        if test x$enable_video_vulkan = xyes; then
    3.16 -            vsdk_include_dir="${VULKAN_SDK}/include"
    3.17 -            vulkan_header="vulkan/vulkan.h"
    3.18 -            save_CPPFLAGS="$CPPFLAGS"
    3.19 -            CPPFLAGS="${save_CPPFLAGS} -I$vsdk_include_dir"
    3.20 -            as_ac_Header=`$as_echo "ac_cv_header_$vulkan_header" | $as_tr_sh`
    3.21 -ac_fn_c_check_header_mongrel "$LINENO" "$vulkan_header" "$as_ac_Header" "$ac_includes_default"
    3.22 -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
    3.23 -  have_vulkan_hdr=yes
    3.24 -else
    3.25 -  have_vulkan_hdr=no
    3.26 -fi
    3.27 -
    3.28 -
    3.29 -            CPPFLAGS="$save_CPPFLAGS"
    3.30 -        fi
    3.31 -    fi
    3.32 -    if test x$have_vulkan_hdr = xyes; then
    3.33 -        # vulkan.h has been found in either $VULKAN_SDK/include or along the
    3.34 -        # the standard include path. Unfortunately there seems no easy
    3.35 -        # way to find out which, so...
    3.36 -        if test -n "$VULKAN_SDK" -a -f "$vsdk_include_dir/$vulkan_header"; then
    3.37 -            EXTRA_CFLAGS="$EXTRA_CFLAGS -I$vsdk_include_dir"
    3.38 -        fi
    3.39 +    fi
    3.40 +    if test x$enable_video_vulkan = xyes; then
    3.41  
    3.42  $as_echo "#define SDL_VIDEO_VULKAN_SURFACE 1" >>confdefs.h
    3.43  
    3.44 @@ -24272,7 +24249,7 @@
    3.45          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,OpenGLES"
    3.46          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
    3.47          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,UIKit"
    3.48 -        if test x$ac_cv_header_vulkan_vulkan_h = xyes; then
    3.49 +        if test x$enable_video_vulkan = xyes; then
    3.50              EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
    3.51          fi
    3.52          ;;
    3.53 @@ -24362,7 +24339,7 @@
    3.54          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Cocoa"
    3.55          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Carbon"
    3.56          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,IOKit"
    3.57 -        if test x$ac_cv_header_vulkan_vulkan_h = xyes; then
    3.58 +        if test x$enable_video_vulkan = xyes; then
    3.59              EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
    3.60          fi
    3.61          ;;
     4.1 --- a/configure.in	Sun Aug 27 19:32:08 2017 -0700
     4.2 +++ b/configure.in	Sun Aug 27 23:25:12 2017 -0400
     4.3 @@ -2409,7 +2409,6 @@
     4.4  dnl Find Vulkan Header
     4.5  CheckVulkan()
     4.6  {
     4.7 -    have_vulkan_hdr=no
     4.8      if test x$enable_video = xyes -a x$enable_video_vulkan = xyes; then
     4.9          case "$host" in
    4.10              *-*-androideabi*)
    4.11 @@ -2434,24 +2433,8 @@
    4.12              # I put this in the AC_TRY_COMPILE.
    4.13              AC_MSG_WARN([Sorry, Vulkan does not work on this configuration.])
    4.14          fi
    4.15 -        if test x$enable_video_vulkan = xyes; then
    4.16 -            vsdk_include_dir="${VULKAN_SDK}/include"
    4.17 -            vulkan_header="vulkan/vulkan.h"
    4.18 -            save_CPPFLAGS="$CPPFLAGS"
    4.19 -            CPPFLAGS="${save_CPPFLAGS} -I$vsdk_include_dir"
    4.20 -            AC_CHECK_HEADER($vulkan_header,
    4.21 -                            have_vulkan_hdr=yes,
    4.22 -                            have_vulkan_hdr=no)
    4.23 -            CPPFLAGS="$save_CPPFLAGS"
    4.24 -        fi
    4.25      fi
    4.26 -    if test x$have_vulkan_hdr = xyes; then
    4.27 -        # vulkan.h has been found in either $VULKAN_SDK/include or along the
    4.28 -        # the standard include path. Unfortunately there seems no easy
    4.29 -        # way to find out which, so...
    4.30 -        if test -n "$VULKAN_SDK" -a -f "$vsdk_include_dir/$vulkan_header"; then 
    4.31 -            EXTRA_CFLAGS="$EXTRA_CFLAGS -I$vsdk_include_dir"
    4.32 -        fi
    4.33 +    if test x$enable_video_vulkan = xyes; then
    4.34          AC_DEFINE(SDL_VIDEO_VULKAN_SURFACE, 1, [ ])
    4.35          SUMMARY_video="${SUMMARY_video} vulkan"
    4.36      fi
    4.37 @@ -3680,7 +3663,7 @@
    4.38          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,OpenGLES"
    4.39          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
    4.40          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,UIKit"
    4.41 -        if test x$ac_cv_header_vulkan_vulkan_h = xyes; then
    4.42 +        if test x$enable_video_vulkan = xyes; then
    4.43              EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
    4.44          fi
    4.45          ;;
    4.46 @@ -3758,7 +3741,7 @@
    4.47          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Cocoa"
    4.48          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Carbon"
    4.49          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,IOKit"
    4.50 -        if test x$ac_cv_header_vulkan_vulkan_h = xyes; then
    4.51 +        if test x$enable_video_vulkan = xyes; then
    4.52              EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
    4.53          fi
    4.54          ;;
     5.1 --- a/src/video/SDL_vulkan_internal.h	Sun Aug 27 19:32:08 2017 -0700
     5.2 +++ b/src/video/SDL_vulkan_internal.h	Sun Aug 27 23:25:12 2017 -0400
     5.3 @@ -59,7 +59,7 @@
     5.4   * inclusion of vulkan has the appropriate USE_PLATFORM defined, hence
     5.5   * the above. */
     5.6  #define VK_NO_PROTOTYPES
     5.7 -#include "vulkan/vulkan.h"
     5.8 +#include "./khronos/vulkan/vulkan.h"
     5.9  
    5.10  extern const char *SDL_Vulkan_GetResultString(VkResult result);
    5.11  
     6.1 --- a/src/video/cocoa/SDL_cocoametalview.m	Sun Aug 27 19:32:08 2017 -0700
     6.2 +++ b/src/video/cocoa/SDL_cocoametalview.m	Sun Aug 27 23:25:12 2017 -0400
     6.3 @@ -26,9 +26,6 @@
     6.4   * how to add a CAMetalLayer backed view.
     6.5   */
     6.6  
     6.7 -/* this is (currently) only used with Vulkan. Remove this #if when that changes! */
     6.8 -#if SDL_VIDEO_VULKAN_SURFACE && SDL_VIDEO_DRIVER_COCOA
     6.9 -
    6.10  #import "SDL_cocoametalview.h"
    6.11  
    6.12  #include "SDL_assert.h"
    6.13 @@ -118,7 +115,5 @@
    6.14      }
    6.15  }
    6.16  
    6.17 -#endif
    6.18 -
    6.19  /* vi: set ts=4 sw=4 expandtab: */
    6.20  
     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/video/khronos/vulkan/vk_platform.h	Sun Aug 27 23:25:12 2017 -0400
     7.3 @@ -0,0 +1,120 @@
     7.4 +//
     7.5 +// File: vk_platform.h
     7.6 +//
     7.7 +/*
     7.8 +** Copyright (c) 2014-2017 The Khronos Group Inc.
     7.9 +**
    7.10 +** Licensed under the Apache License, Version 2.0 (the "License");
    7.11 +** you may not use this file except in compliance with the License.
    7.12 +** You may obtain a copy of the License at
    7.13 +**
    7.14 +**     http://www.apache.org/licenses/LICENSE-2.0
    7.15 +**
    7.16 +** Unless required by applicable law or agreed to in writing, software
    7.17 +** distributed under the License is distributed on an "AS IS" BASIS,
    7.18 +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    7.19 +** See the License for the specific language governing permissions and
    7.20 +** limitations under the License.
    7.21 +*/
    7.22 +
    7.23 +
    7.24 +#ifndef VK_PLATFORM_H_
    7.25 +#define VK_PLATFORM_H_
    7.26 +
    7.27 +#ifdef __cplusplus
    7.28 +extern "C"
    7.29 +{
    7.30 +#endif // __cplusplus
    7.31 +
    7.32 +/*
    7.33 +***************************************************************************************************
    7.34 +*   Platform-specific directives and type declarations
    7.35 +***************************************************************************************************
    7.36 +*/
    7.37 +
    7.38 +/* Platform-specific calling convention macros.
    7.39 + *
    7.40 + * Platforms should define these so that Vulkan clients call Vulkan commands
    7.41 + * with the same calling conventions that the Vulkan implementation expects.
    7.42 + *
    7.43 + * VKAPI_ATTR - Placed before the return type in function declarations.
    7.44 + *              Useful for C++11 and GCC/Clang-style function attribute syntax.
    7.45 + * VKAPI_CALL - Placed after the return type in function declarations.
    7.46 + *              Useful for MSVC-style calling convention syntax.
    7.47 + * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
    7.48 + *
    7.49 + * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
    7.50 + * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
    7.51 + */
    7.52 +#if defined(_WIN32)
    7.53 +    // On Windows, Vulkan commands use the stdcall convention
    7.54 +    #define VKAPI_ATTR
    7.55 +    #define VKAPI_CALL __stdcall
    7.56 +    #define VKAPI_PTR  VKAPI_CALL
    7.57 +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
    7.58 +    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
    7.59 +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
    7.60 +    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
    7.61 +    // calling convention, i.e. float parameters are passed in registers. This
    7.62 +    // is true even if the rest of the application passes floats on the stack,
    7.63 +    // as it does by default when compiling for the armeabi-v7a NDK ABI.
    7.64 +    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
    7.65 +    #define VKAPI_CALL
    7.66 +    #define VKAPI_PTR  VKAPI_ATTR
    7.67 +#else
    7.68 +    // On other platforms, use the default calling convention
    7.69 +    #define VKAPI_ATTR
    7.70 +    #define VKAPI_CALL
    7.71 +    #define VKAPI_PTR
    7.72 +#endif
    7.73 +
    7.74 +#include <stddef.h>
    7.75 +
    7.76 +#if !defined(VK_NO_STDINT_H)
    7.77 +    #if defined(_MSC_VER) && (_MSC_VER < 1600)
    7.78 +        typedef signed   __int8  int8_t;
    7.79 +        typedef unsigned __int8  uint8_t;
    7.80 +        typedef signed   __int16 int16_t;
    7.81 +        typedef unsigned __int16 uint16_t;
    7.82 +        typedef signed   __int32 int32_t;
    7.83 +        typedef unsigned __int32 uint32_t;
    7.84 +        typedef signed   __int64 int64_t;
    7.85 +        typedef unsigned __int64 uint64_t;
    7.86 +    #else
    7.87 +        #include <stdint.h>
    7.88 +    #endif
    7.89 +#endif // !defined(VK_NO_STDINT_H)
    7.90 +
    7.91 +#ifdef __cplusplus
    7.92 +} // extern "C"
    7.93 +#endif // __cplusplus
    7.94 +
    7.95 +// Platform-specific headers required by platform window system extensions.
    7.96 +// These are enabled prior to #including "vulkan.h". The same enable then
    7.97 +// controls inclusion of the extension interfaces in vulkan.h.
    7.98 +
    7.99 +#ifdef VK_USE_PLATFORM_ANDROID_KHR
   7.100 +#include <android/native_window.h>
   7.101 +#endif
   7.102 +
   7.103 +#ifdef VK_USE_PLATFORM_MIR_KHR
   7.104 +#include <mir_toolkit/client_types.h>
   7.105 +#endif
   7.106 +
   7.107 +#ifdef VK_USE_PLATFORM_WAYLAND_KHR
   7.108 +#include <wayland-client.h>
   7.109 +#endif
   7.110 +
   7.111 +#ifdef VK_USE_PLATFORM_WIN32_KHR
   7.112 +#include <windows.h>
   7.113 +#endif
   7.114 +
   7.115 +#ifdef VK_USE_PLATFORM_XLIB_KHR
   7.116 +#include <X11/Xlib.h>
   7.117 +#endif
   7.118 +
   7.119 +#ifdef VK_USE_PLATFORM_XCB_KHR
   7.120 +#include <xcb/xcb.h>
   7.121 +#endif
   7.122 +
   7.123 +#endif
     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/video/khronos/vulkan/vulkan.h	Sun Aug 27 23:25:12 2017 -0400
     8.3 @@ -0,0 +1,6458 @@
     8.4 +#ifndef VULKAN_H_
     8.5 +#define VULKAN_H_ 1
     8.6 +
     8.7 +#ifdef __cplusplus
     8.8 +extern "C" {
     8.9 +#endif
    8.10 +
    8.11 +/*
    8.12 +** Copyright (c) 2015-2017 The Khronos Group Inc.
    8.13 +**
    8.14 +** Licensed under the Apache License, Version 2.0 (the "License");
    8.15 +** you may not use this file except in compliance with the License.
    8.16 +** You may obtain a copy of the License at
    8.17 +**
    8.18 +**     http://www.apache.org/licenses/LICENSE-2.0
    8.19 +**
    8.20 +** Unless required by applicable law or agreed to in writing, software
    8.21 +** distributed under the License is distributed on an "AS IS" BASIS,
    8.22 +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    8.23 +** See the License for the specific language governing permissions and
    8.24 +** limitations under the License.
    8.25 +*/
    8.26 +
    8.27 +/*
    8.28 +** This header is generated from the Khronos Vulkan XML API Registry.
    8.29 +**
    8.30 +*/
    8.31 +
    8.32 +
    8.33 +#define VK_VERSION_1_0 1
    8.34 +#include "./vk_platform.h"
    8.35 +
    8.36 +#define VK_MAKE_VERSION(major, minor, patch) \
    8.37 +    (((major) << 22) | ((minor) << 12) | (patch))
    8.38 +
    8.39 +// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
    8.40 +//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
    8.41 +
    8.42 +// Vulkan 1.0 version number
    8.43 +#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
    8.44 +
    8.45 +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
    8.46 +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
    8.47 +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
    8.48 +// Version of this file
    8.49 +#define VK_HEADER_VERSION 59
    8.50 +
    8.51 +
    8.52 +#define VK_NULL_HANDLE 0
    8.53 +        
    8.54 +
    8.55 +
    8.56 +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
    8.57 +
    8.58 +
    8.59 +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
    8.60 +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
    8.61 +        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
    8.62 +#else
    8.63 +        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
    8.64 +#endif
    8.65 +#endif
    8.66 +        
    8.67 +
    8.68 +
    8.69 +typedef uint32_t VkFlags;
    8.70 +typedef uint32_t VkBool32;
    8.71 +typedef uint64_t VkDeviceSize;
    8.72 +typedef uint32_t VkSampleMask;
    8.73 +
    8.74 +VK_DEFINE_HANDLE(VkInstance)
    8.75 +VK_DEFINE_HANDLE(VkPhysicalDevice)
    8.76 +VK_DEFINE_HANDLE(VkDevice)
    8.77 +VK_DEFINE_HANDLE(VkQueue)
    8.78 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
    8.79 +VK_DEFINE_HANDLE(VkCommandBuffer)
    8.80 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
    8.81 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
    8.82 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
    8.83 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
    8.84 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
    8.85 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
    8.86 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
    8.87 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
    8.88 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
    8.89 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
    8.90 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
    8.91 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
    8.92 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
    8.93 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
    8.94 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
    8.95 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
    8.96 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
    8.97 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
    8.98 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
    8.99 +
   8.100 +#define VK_LOD_CLAMP_NONE                 1000.0f
   8.101 +#define VK_REMAINING_MIP_LEVELS           (~0U)
   8.102 +#define VK_REMAINING_ARRAY_LAYERS         (~0U)
   8.103 +#define VK_WHOLE_SIZE                     (~0ULL)
   8.104 +#define VK_ATTACHMENT_UNUSED              (~0U)
   8.105 +#define VK_TRUE                           1
   8.106 +#define VK_FALSE                          0
   8.107 +#define VK_QUEUE_FAMILY_IGNORED           (~0U)
   8.108 +#define VK_SUBPASS_EXTERNAL               (~0U)
   8.109 +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
   8.110 +#define VK_UUID_SIZE                      16
   8.111 +#define VK_MAX_MEMORY_TYPES               32
   8.112 +#define VK_MAX_MEMORY_HEAPS               16
   8.113 +#define VK_MAX_EXTENSION_NAME_SIZE        256
   8.114 +#define VK_MAX_DESCRIPTION_SIZE           256
   8.115 +
   8.116 +
   8.117 +typedef enum VkPipelineCacheHeaderVersion {
   8.118 +    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
   8.119 +    VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
   8.120 +    VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
   8.121 +    VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
   8.122 +    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
   8.123 +} VkPipelineCacheHeaderVersion;
   8.124 +
   8.125 +typedef enum VkResult {
   8.126 +    VK_SUCCESS = 0,
   8.127 +    VK_NOT_READY = 1,
   8.128 +    VK_TIMEOUT = 2,
   8.129 +    VK_EVENT_SET = 3,
   8.130 +    VK_EVENT_RESET = 4,
   8.131 +    VK_INCOMPLETE = 5,
   8.132 +    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
   8.133 +    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
   8.134 +    VK_ERROR_INITIALIZATION_FAILED = -3,
   8.135 +    VK_ERROR_DEVICE_LOST = -4,
   8.136 +    VK_ERROR_MEMORY_MAP_FAILED = -5,
   8.137 +    VK_ERROR_LAYER_NOT_PRESENT = -6,
   8.138 +    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
   8.139 +    VK_ERROR_FEATURE_NOT_PRESENT = -8,
   8.140 +    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
   8.141 +    VK_ERROR_TOO_MANY_OBJECTS = -10,
   8.142 +    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
   8.143 +    VK_ERROR_FRAGMENTED_POOL = -12,
   8.144 +    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
   8.145 +    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
   8.146 +    VK_SUBOPTIMAL_KHR = 1000001003,
   8.147 +    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
   8.148 +    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
   8.149 +    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
   8.150 +    VK_ERROR_INVALID_SHADER_NV = -1000012000,
   8.151 +    VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
   8.152 +    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003,
   8.153 +    VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
   8.154 +    VK_RESULT_END_RANGE = VK_INCOMPLETE,
   8.155 +    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
   8.156 +    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
   8.157 +} VkResult;
   8.158 +
   8.159 +typedef enum VkStructureType {
   8.160 +    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
   8.161 +    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
   8.162 +    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
   8.163 +    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
   8.164 +    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
   8.165 +    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
   8.166 +    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
   8.167 +    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
   8.168 +    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
   8.169 +    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
   8.170 +    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
   8.171 +    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
   8.172 +    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
   8.173 +    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
   8.174 +    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
   8.175 +    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
   8.176 +    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
   8.177 +    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
   8.178 +    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
   8.179 +    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
   8.180 +    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
   8.181 +    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
   8.182 +    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
   8.183 +    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
   8.184 +    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
   8.185 +    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
   8.186 +    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
   8.187 +    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
   8.188 +    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
   8.189 +    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
   8.190 +    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
   8.191 +    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
   8.192 +    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
   8.193 +    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
   8.194 +    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
   8.195 +    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
   8.196 +    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
   8.197 +    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
   8.198 +    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
   8.199 +    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
   8.200 +    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
   8.201 +    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
   8.202 +    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
   8.203 +    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
   8.204 +    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
   8.205 +    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
   8.206 +    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
   8.207 +    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
   8.208 +    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
   8.209 +    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
   8.210 +    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
   8.211 +    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
   8.212 +    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
   8.213 +    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
   8.214 +    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
   8.215 +    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
   8.216 +    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
   8.217 +    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
   8.218 +    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
   8.219 +    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
   8.220 +    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
   8.221 +    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
   8.222 +    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
   8.223 +    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
   8.224 +    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
   8.225 +    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
   8.226 +    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
   8.227 +    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
   8.228 +    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
   8.229 +    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
   8.230 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
   8.231 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
   8.232 +    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
   8.233 +    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
   8.234 +    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
   8.235 +    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
   8.236 +    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
   8.237 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
   8.238 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
   8.239 +    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
   8.240 +    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
   8.241 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
   8.242 +    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
   8.243 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
   8.244 +    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
   8.245 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
   8.246 +    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000,
   8.247 +    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = 1000060001,
   8.248 +    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = 1000060002,
   8.249 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003,
   8.250 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004,
   8.251 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005,
   8.252 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006,
   8.253 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007,
   8.254 +    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008,
   8.255 +    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009,
   8.256 +    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010,
   8.257 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011,
   8.258 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012,
   8.259 +    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
   8.260 +    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
   8.261 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000,
   8.262 +    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001,
   8.263 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000,
   8.264 +    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001,
   8.265 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002,
   8.266 +    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003,
   8.267 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004,
   8.268 +    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000,
   8.269 +    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001,
   8.270 +    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002,
   8.271 +    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
   8.272 +    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
   8.273 +    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
   8.274 +    VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
   8.275 +    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
   8.276 +    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
   8.277 +    VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
   8.278 +    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
   8.279 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000,
   8.280 +    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001,
   8.281 +    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000,
   8.282 +    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
   8.283 +    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
   8.284 +    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
   8.285 +    VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
   8.286 +    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
   8.287 +    VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
   8.288 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
   8.289 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
   8.290 +    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
   8.291 +    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
   8.292 +    VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
   8.293 +    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
   8.294 +    VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
   8.295 +    VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
   8.296 +    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
   8.297 +    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
   8.298 +    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
   8.299 +    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
   8.300 +    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
   8.301 +    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
   8.302 +    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
   8.303 +    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
   8.304 +    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
   8.305 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
   8.306 +    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
   8.307 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
   8.308 +    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
   8.309 +    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
   8.310 +    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
   8.311 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000,
   8.312 +    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001,
   8.313 +    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000,
   8.314 +    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
   8.315 +    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
   8.316 +    VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
   8.317 +    VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
   8.318 +    VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
   8.319 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
   8.320 +    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
   8.321 +    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
   8.322 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,
   8.323 +    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
   8.324 +    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
   8.325 +    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000,
   8.326 +    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001,
   8.327 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
   8.328 +    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
   8.329 +    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000,
   8.330 +    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001,
   8.331 +    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
   8.332 +    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003,
   8.333 +    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
   8.334 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
   8.335 +    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
   8.336 +    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
   8.337 +    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
   8.338 +    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
   8.339 +    VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
   8.340 +    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
   8.341 +    VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
   8.342 +    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.343 +} VkStructureType;
   8.344 +
   8.345 +typedef enum VkSystemAllocationScope {
   8.346 +    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
   8.347 +    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
   8.348 +    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
   8.349 +    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
   8.350 +    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
   8.351 +    VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
   8.352 +    VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
   8.353 +    VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
   8.354 +    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
   8.355 +} VkSystemAllocationScope;
   8.356 +
   8.357 +typedef enum VkInternalAllocationType {
   8.358 +    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
   8.359 +    VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
   8.360 +    VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
   8.361 +    VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
   8.362 +    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.363 +} VkInternalAllocationType;
   8.364 +
   8.365 +typedef enum VkFormat {
   8.366 +    VK_FORMAT_UNDEFINED = 0,
   8.367 +    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
   8.368 +    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
   8.369 +    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
   8.370 +    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
   8.371 +    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
   8.372 +    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
   8.373 +    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
   8.374 +    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
   8.375 +    VK_FORMAT_R8_UNORM = 9,
   8.376 +    VK_FORMAT_R8_SNORM = 10,
   8.377 +    VK_FORMAT_R8_USCALED = 11,
   8.378 +    VK_FORMAT_R8_SSCALED = 12,
   8.379 +    VK_FORMAT_R8_UINT = 13,
   8.380 +    VK_FORMAT_R8_SINT = 14,
   8.381 +    VK_FORMAT_R8_SRGB = 15,
   8.382 +    VK_FORMAT_R8G8_UNORM = 16,
   8.383 +    VK_FORMAT_R8G8_SNORM = 17,
   8.384 +    VK_FORMAT_R8G8_USCALED = 18,
   8.385 +    VK_FORMAT_R8G8_SSCALED = 19,
   8.386 +    VK_FORMAT_R8G8_UINT = 20,
   8.387 +    VK_FORMAT_R8G8_SINT = 21,
   8.388 +    VK_FORMAT_R8G8_SRGB = 22,
   8.389 +    VK_FORMAT_R8G8B8_UNORM = 23,
   8.390 +    VK_FORMAT_R8G8B8_SNORM = 24,
   8.391 +    VK_FORMAT_R8G8B8_USCALED = 25,
   8.392 +    VK_FORMAT_R8G8B8_SSCALED = 26,
   8.393 +    VK_FORMAT_R8G8B8_UINT = 27,
   8.394 +    VK_FORMAT_R8G8B8_SINT = 28,
   8.395 +    VK_FORMAT_R8G8B8_SRGB = 29,
   8.396 +    VK_FORMAT_B8G8R8_UNORM = 30,
   8.397 +    VK_FORMAT_B8G8R8_SNORM = 31,
   8.398 +    VK_FORMAT_B8G8R8_USCALED = 32,
   8.399 +    VK_FORMAT_B8G8R8_SSCALED = 33,
   8.400 +    VK_FORMAT_B8G8R8_UINT = 34,
   8.401 +    VK_FORMAT_B8G8R8_SINT = 35,
   8.402 +    VK_FORMAT_B8G8R8_SRGB = 36,
   8.403 +    VK_FORMAT_R8G8B8A8_UNORM = 37,
   8.404 +    VK_FORMAT_R8G8B8A8_SNORM = 38,
   8.405 +    VK_FORMAT_R8G8B8A8_USCALED = 39,
   8.406 +    VK_FORMAT_R8G8B8A8_SSCALED = 40,
   8.407 +    VK_FORMAT_R8G8B8A8_UINT = 41,
   8.408 +    VK_FORMAT_R8G8B8A8_SINT = 42,
   8.409 +    VK_FORMAT_R8G8B8A8_SRGB = 43,
   8.410 +    VK_FORMAT_B8G8R8A8_UNORM = 44,
   8.411 +    VK_FORMAT_B8G8R8A8_SNORM = 45,
   8.412 +    VK_FORMAT_B8G8R8A8_USCALED = 46,
   8.413 +    VK_FORMAT_B8G8R8A8_SSCALED = 47,
   8.414 +    VK_FORMAT_B8G8R8A8_UINT = 48,
   8.415 +    VK_FORMAT_B8G8R8A8_SINT = 49,
   8.416 +    VK_FORMAT_B8G8R8A8_SRGB = 50,
   8.417 +    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
   8.418 +    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
   8.419 +    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
   8.420 +    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
   8.421 +    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
   8.422 +    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
   8.423 +    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
   8.424 +    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
   8.425 +    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
   8.426 +    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
   8.427 +    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
   8.428 +    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
   8.429 +    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
   8.430 +    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
   8.431 +    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
   8.432 +    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
   8.433 +    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
   8.434 +    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
   8.435 +    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
   8.436 +    VK_FORMAT_R16_UNORM = 70,
   8.437 +    VK_FORMAT_R16_SNORM = 71,
   8.438 +    VK_FORMAT_R16_USCALED = 72,
   8.439 +    VK_FORMAT_R16_SSCALED = 73,
   8.440 +    VK_FORMAT_R16_UINT = 74,
   8.441 +    VK_FORMAT_R16_SINT = 75,
   8.442 +    VK_FORMAT_R16_SFLOAT = 76,
   8.443 +    VK_FORMAT_R16G16_UNORM = 77,
   8.444 +    VK_FORMAT_R16G16_SNORM = 78,
   8.445 +    VK_FORMAT_R16G16_USCALED = 79,
   8.446 +    VK_FORMAT_R16G16_SSCALED = 80,
   8.447 +    VK_FORMAT_R16G16_UINT = 81,
   8.448 +    VK_FORMAT_R16G16_SINT = 82,
   8.449 +    VK_FORMAT_R16G16_SFLOAT = 83,
   8.450 +    VK_FORMAT_R16G16B16_UNORM = 84,
   8.451 +    VK_FORMAT_R16G16B16_SNORM = 85,
   8.452 +    VK_FORMAT_R16G16B16_USCALED = 86,
   8.453 +    VK_FORMAT_R16G16B16_SSCALED = 87,
   8.454 +    VK_FORMAT_R16G16B16_UINT = 88,
   8.455 +    VK_FORMAT_R16G16B16_SINT = 89,
   8.456 +    VK_FORMAT_R16G16B16_SFLOAT = 90,
   8.457 +    VK_FORMAT_R16G16B16A16_UNORM = 91,
   8.458 +    VK_FORMAT_R16G16B16A16_SNORM = 92,
   8.459 +    VK_FORMAT_R16G16B16A16_USCALED = 93,
   8.460 +    VK_FORMAT_R16G16B16A16_SSCALED = 94,
   8.461 +    VK_FORMAT_R16G16B16A16_UINT = 95,
   8.462 +    VK_FORMAT_R16G16B16A16_SINT = 96,
   8.463 +    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
   8.464 +    VK_FORMAT_R32_UINT = 98,
   8.465 +    VK_FORMAT_R32_SINT = 99,
   8.466 +    VK_FORMAT_R32_SFLOAT = 100,
   8.467 +    VK_FORMAT_R32G32_UINT = 101,
   8.468 +    VK_FORMAT_R32G32_SINT = 102,
   8.469 +    VK_FORMAT_R32G32_SFLOAT = 103,
   8.470 +    VK_FORMAT_R32G32B32_UINT = 104,
   8.471 +    VK_FORMAT_R32G32B32_SINT = 105,
   8.472 +    VK_FORMAT_R32G32B32_SFLOAT = 106,
   8.473 +    VK_FORMAT_R32G32B32A32_UINT = 107,
   8.474 +    VK_FORMAT_R32G32B32A32_SINT = 108,
   8.475 +    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
   8.476 +    VK_FORMAT_R64_UINT = 110,
   8.477 +    VK_FORMAT_R64_SINT = 111,
   8.478 +    VK_FORMAT_R64_SFLOAT = 112,
   8.479 +    VK_FORMAT_R64G64_UINT = 113,
   8.480 +    VK_FORMAT_R64G64_SINT = 114,
   8.481 +    VK_FORMAT_R64G64_SFLOAT = 115,
   8.482 +    VK_FORMAT_R64G64B64_UINT = 116,
   8.483 +    VK_FORMAT_R64G64B64_SINT = 117,
   8.484 +    VK_FORMAT_R64G64B64_SFLOAT = 118,
   8.485 +    VK_FORMAT_R64G64B64A64_UINT = 119,
   8.486 +    VK_FORMAT_R64G64B64A64_SINT = 120,
   8.487 +    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
   8.488 +    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
   8.489 +    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
   8.490 +    VK_FORMAT_D16_UNORM = 124,
   8.491 +    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
   8.492 +    VK_FORMAT_D32_SFLOAT = 126,
   8.493 +    VK_FORMAT_S8_UINT = 127,
   8.494 +    VK_FORMAT_D16_UNORM_S8_UINT = 128,
   8.495 +    VK_FORMAT_D24_UNORM_S8_UINT = 129,
   8.496 +    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
   8.497 +    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
   8.498 +    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
   8.499 +    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
   8.500 +    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
   8.501 +    VK_FORMAT_BC2_UNORM_BLOCK = 135,
   8.502 +    VK_FORMAT_BC2_SRGB_BLOCK = 136,
   8.503 +    VK_FORMAT_BC3_UNORM_BLOCK = 137,
   8.504 +    VK_FORMAT_BC3_SRGB_BLOCK = 138,
   8.505 +    VK_FORMAT_BC4_UNORM_BLOCK = 139,
   8.506 +    VK_FORMAT_BC4_SNORM_BLOCK = 140,
   8.507 +    VK_FORMAT_BC5_UNORM_BLOCK = 141,
   8.508 +    VK_FORMAT_BC5_SNORM_BLOCK = 142,
   8.509 +    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
   8.510 +    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
   8.511 +    VK_FORMAT_BC7_UNORM_BLOCK = 145,
   8.512 +    VK_FORMAT_BC7_SRGB_BLOCK = 146,
   8.513 +    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
   8.514 +    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
   8.515 +    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
   8.516 +    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
   8.517 +    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
   8.518 +    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
   8.519 +    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
   8.520 +    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
   8.521 +    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
   8.522 +    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
   8.523 +    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
   8.524 +    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
   8.525 +    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
   8.526 +    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
   8.527 +    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
   8.528 +    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
   8.529 +    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
   8.530 +    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
   8.531 +    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
   8.532 +    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
   8.533 +    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
   8.534 +    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
   8.535 +    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
   8.536 +    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
   8.537 +    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
   8.538 +    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
   8.539 +    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
   8.540 +    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
   8.541 +    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
   8.542 +    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
   8.543 +    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
   8.544 +    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
   8.545 +    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
   8.546 +    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
   8.547 +    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
   8.548 +    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
   8.549 +    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
   8.550 +    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
   8.551 +    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
   8.552 +    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
   8.553 +    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
   8.554 +    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
   8.555 +    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
   8.556 +    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
   8.557 +    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
   8.558 +    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
   8.559 +    VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
   8.560 +    VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
   8.561 +    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
   8.562 +    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
   8.563 +} VkFormat;
   8.564 +
   8.565 +typedef enum VkImageType {
   8.566 +    VK_IMAGE_TYPE_1D = 0,
   8.567 +    VK_IMAGE_TYPE_2D = 1,
   8.568 +    VK_IMAGE_TYPE_3D = 2,
   8.569 +    VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
   8.570 +    VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
   8.571 +    VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
   8.572 +    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.573 +} VkImageType;
   8.574 +
   8.575 +typedef enum VkImageTiling {
   8.576 +    VK_IMAGE_TILING_OPTIMAL = 0,
   8.577 +    VK_IMAGE_TILING_LINEAR = 1,
   8.578 +    VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
   8.579 +    VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
   8.580 +    VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
   8.581 +    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
   8.582 +} VkImageTiling;
   8.583 +
   8.584 +typedef enum VkPhysicalDeviceType {
   8.585 +    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
   8.586 +    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
   8.587 +    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
   8.588 +    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
   8.589 +    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
   8.590 +    VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
   8.591 +    VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
   8.592 +    VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
   8.593 +    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.594 +} VkPhysicalDeviceType;
   8.595 +
   8.596 +typedef enum VkQueryType {
   8.597 +    VK_QUERY_TYPE_OCCLUSION = 0,
   8.598 +    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
   8.599 +    VK_QUERY_TYPE_TIMESTAMP = 2,
   8.600 +    VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
   8.601 +    VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
   8.602 +    VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
   8.603 +    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.604 +} VkQueryType;
   8.605 +
   8.606 +typedef enum VkSharingMode {
   8.607 +    VK_SHARING_MODE_EXCLUSIVE = 0,
   8.608 +    VK_SHARING_MODE_CONCURRENT = 1,
   8.609 +    VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
   8.610 +    VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
   8.611 +    VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
   8.612 +    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
   8.613 +} VkSharingMode;
   8.614 +
   8.615 +typedef enum VkImageLayout {
   8.616 +    VK_IMAGE_LAYOUT_UNDEFINED = 0,
   8.617 +    VK_IMAGE_LAYOUT_GENERAL = 1,
   8.618 +    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
   8.619 +    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
   8.620 +    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
   8.621 +    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
   8.622 +    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
   8.623 +    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
   8.624 +    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
   8.625 +    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
   8.626 +    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
   8.627 +    VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
   8.628 +    VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
   8.629 +    VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
   8.630 +    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
   8.631 +} VkImageLayout;
   8.632 +
   8.633 +typedef enum VkImageViewType {
   8.634 +    VK_IMAGE_VIEW_TYPE_1D = 0,
   8.635 +    VK_IMAGE_VIEW_TYPE_2D = 1,
   8.636 +    VK_IMAGE_VIEW_TYPE_3D = 2,
   8.637 +    VK_IMAGE_VIEW_TYPE_CUBE = 3,
   8.638 +    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
   8.639 +    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
   8.640 +    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
   8.641 +    VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
   8.642 +    VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
   8.643 +    VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
   8.644 +    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.645 +} VkImageViewType;
   8.646 +
   8.647 +typedef enum VkComponentSwizzle {
   8.648 +    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
   8.649 +    VK_COMPONENT_SWIZZLE_ZERO = 1,
   8.650 +    VK_COMPONENT_SWIZZLE_ONE = 2,
   8.651 +    VK_COMPONENT_SWIZZLE_R = 3,
   8.652 +    VK_COMPONENT_SWIZZLE_G = 4,
   8.653 +    VK_COMPONENT_SWIZZLE_B = 5,
   8.654 +    VK_COMPONENT_SWIZZLE_A = 6,
   8.655 +    VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
   8.656 +    VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
   8.657 +    VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
   8.658 +    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
   8.659 +} VkComponentSwizzle;
   8.660 +
   8.661 +typedef enum VkVertexInputRate {
   8.662 +    VK_VERTEX_INPUT_RATE_VERTEX = 0,
   8.663 +    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
   8.664 +    VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
   8.665 +    VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
   8.666 +    VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
   8.667 +    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
   8.668 +} VkVertexInputRate;
   8.669 +
   8.670 +typedef enum VkPrimitiveTopology {
   8.671 +    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
   8.672 +    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
   8.673 +    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
   8.674 +    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
   8.675 +    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
   8.676 +    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
   8.677 +    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
   8.678 +    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
   8.679 +    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
   8.680 +    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
   8.681 +    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
   8.682 +    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
   8.683 +    VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
   8.684 +    VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
   8.685 +    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
   8.686 +} VkPrimitiveTopology;
   8.687 +
   8.688 +typedef enum VkPolygonMode {
   8.689 +    VK_POLYGON_MODE_FILL = 0,
   8.690 +    VK_POLYGON_MODE_LINE = 1,
   8.691 +    VK_POLYGON_MODE_POINT = 2,
   8.692 +    VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
   8.693 +    VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
   8.694 +    VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
   8.695 +    VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
   8.696 +    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
   8.697 +} VkPolygonMode;
   8.698 +
   8.699 +typedef enum VkFrontFace {
   8.700 +    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
   8.701 +    VK_FRONT_FACE_CLOCKWISE = 1,
   8.702 +    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
   8.703 +    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
   8.704 +    VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
   8.705 +    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
   8.706 +} VkFrontFace;
   8.707 +
   8.708 +typedef enum VkCompareOp {
   8.709 +    VK_COMPARE_OP_NEVER = 0,
   8.710 +    VK_COMPARE_OP_LESS = 1,
   8.711 +    VK_COMPARE_OP_EQUAL = 2,
   8.712 +    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
   8.713 +    VK_COMPARE_OP_GREATER = 4,
   8.714 +    VK_COMPARE_OP_NOT_EQUAL = 5,
   8.715 +    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
   8.716 +    VK_COMPARE_OP_ALWAYS = 7,
   8.717 +    VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
   8.718 +    VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
   8.719 +    VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
   8.720 +    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
   8.721 +} VkCompareOp;
   8.722 +
   8.723 +typedef enum VkStencilOp {
   8.724 +    VK_STENCIL_OP_KEEP = 0,
   8.725 +    VK_STENCIL_OP_ZERO = 1,
   8.726 +    VK_STENCIL_OP_REPLACE = 2,
   8.727 +    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
   8.728 +    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
   8.729 +    VK_STENCIL_OP_INVERT = 5,
   8.730 +    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
   8.731 +    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
   8.732 +    VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
   8.733 +    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
   8.734 +    VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
   8.735 +    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
   8.736 +} VkStencilOp;
   8.737 +
   8.738 +typedef enum VkLogicOp {
   8.739 +    VK_LOGIC_OP_CLEAR = 0,
   8.740 +    VK_LOGIC_OP_AND = 1,
   8.741 +    VK_LOGIC_OP_AND_REVERSE = 2,
   8.742 +    VK_LOGIC_OP_COPY = 3,
   8.743 +    VK_LOGIC_OP_AND_INVERTED = 4,
   8.744 +    VK_LOGIC_OP_NO_OP = 5,
   8.745 +    VK_LOGIC_OP_XOR = 6,
   8.746 +    VK_LOGIC_OP_OR = 7,
   8.747 +    VK_LOGIC_OP_NOR = 8,
   8.748 +    VK_LOGIC_OP_EQUIVALENT = 9,
   8.749 +    VK_LOGIC_OP_INVERT = 10,
   8.750 +    VK_LOGIC_OP_OR_REVERSE = 11,
   8.751 +    VK_LOGIC_OP_COPY_INVERTED = 12,
   8.752 +    VK_LOGIC_OP_OR_INVERTED = 13,
   8.753 +    VK_LOGIC_OP_NAND = 14,
   8.754 +    VK_LOGIC_OP_SET = 15,
   8.755 +    VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
   8.756 +    VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
   8.757 +    VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
   8.758 +    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
   8.759 +} VkLogicOp;
   8.760 +
   8.761 +typedef enum VkBlendFactor {
   8.762 +    VK_BLEND_FACTOR_ZERO = 0,
   8.763 +    VK_BLEND_FACTOR_ONE = 1,
   8.764 +    VK_BLEND_FACTOR_SRC_COLOR = 2,
   8.765 +    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
   8.766 +    VK_BLEND_FACTOR_DST_COLOR = 4,
   8.767 +    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
   8.768 +    VK_BLEND_FACTOR_SRC_ALPHA = 6,
   8.769 +    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
   8.770 +    VK_BLEND_FACTOR_DST_ALPHA = 8,
   8.771 +    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
   8.772 +    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
   8.773 +    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
   8.774 +    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
   8.775 +    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
   8.776 +    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
   8.777 +    VK_BLEND_FACTOR_SRC1_COLOR = 15,
   8.778 +    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
   8.779 +    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
   8.780 +    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
   8.781 +    VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
   8.782 +    VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
   8.783 +    VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
   8.784 +    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
   8.785 +} VkBlendFactor;
   8.786 +
   8.787 +typedef enum VkBlendOp {
   8.788 +    VK_BLEND_OP_ADD = 0,
   8.789 +    VK_BLEND_OP_SUBTRACT = 1,
   8.790 +    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
   8.791 +    VK_BLEND_OP_MIN = 3,
   8.792 +    VK_BLEND_OP_MAX = 4,
   8.793 +    VK_BLEND_OP_ZERO_EXT = 1000148000,
   8.794 +    VK_BLEND_OP_SRC_EXT = 1000148001,
   8.795 +    VK_BLEND_OP_DST_EXT = 1000148002,
   8.796 +    VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
   8.797 +    VK_BLEND_OP_DST_OVER_EXT = 1000148004,
   8.798 +    VK_BLEND_OP_SRC_IN_EXT = 1000148005,
   8.799 +    VK_BLEND_OP_DST_IN_EXT = 1000148006,
   8.800 +    VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
   8.801 +    VK_BLEND_OP_DST_OUT_EXT = 1000148008,
   8.802 +    VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
   8.803 +    VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
   8.804 +    VK_BLEND_OP_XOR_EXT = 1000148011,
   8.805 +    VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
   8.806 +    VK_BLEND_OP_SCREEN_EXT = 1000148013,
   8.807 +    VK_BLEND_OP_OVERLAY_EXT = 1000148014,
   8.808 +    VK_BLEND_OP_DARKEN_EXT = 1000148015,
   8.809 +    VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
   8.810 +    VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
   8.811 +    VK_BLEND_OP_COLORBURN_EXT = 1000148018,
   8.812 +    VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
   8.813 +    VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
   8.814 +    VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
   8.815 +    VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
   8.816 +    VK_BLEND_OP_INVERT_EXT = 1000148023,
   8.817 +    VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
   8.818 +    VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
   8.819 +    VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
   8.820 +    VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
   8.821 +    VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
   8.822 +    VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
   8.823 +    VK_BLEND_OP_HARDMIX_EXT = 1000148030,
   8.824 +    VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
   8.825 +    VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
   8.826 +    VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
   8.827 +    VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
   8.828 +    VK_BLEND_OP_PLUS_EXT = 1000148035,
   8.829 +    VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
   8.830 +    VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
   8.831 +    VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
   8.832 +    VK_BLEND_OP_MINUS_EXT = 1000148039,
   8.833 +    VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
   8.834 +    VK_BLEND_OP_CONTRAST_EXT = 1000148041,
   8.835 +    VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
   8.836 +    VK_BLEND_OP_RED_EXT = 1000148043,
   8.837 +    VK_BLEND_OP_GREEN_EXT = 1000148044,
   8.838 +    VK_BLEND_OP_BLUE_EXT = 1000148045,
   8.839 +    VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
   8.840 +    VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
   8.841 +    VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
   8.842 +    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
   8.843 +} VkBlendOp;
   8.844 +
   8.845 +typedef enum VkDynamicState {
   8.846 +    VK_DYNAMIC_STATE_VIEWPORT = 0,
   8.847 +    VK_DYNAMIC_STATE_SCISSOR = 1,
   8.848 +    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
   8.849 +    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
   8.850 +    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
   8.851 +    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
   8.852 +    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
   8.853 +    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
   8.854 +    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
   8.855 +    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
   8.856 +    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
   8.857 +    VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
   8.858 +    VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
   8.859 +    VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
   8.860 +    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
   8.861 +} VkDynamicState;
   8.862 +
   8.863 +typedef enum VkFilter {
   8.864 +    VK_FILTER_NEAREST = 0,
   8.865 +    VK_FILTER_LINEAR = 1,
   8.866 +    VK_FILTER_CUBIC_IMG = 1000015000,
   8.867 +    VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
   8.868 +    VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
   8.869 +    VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
   8.870 +    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
   8.871 +} VkFilter;
   8.872 +
   8.873 +typedef enum VkSamplerMipmapMode {
   8.874 +    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
   8.875 +    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
   8.876 +    VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
   8.877 +    VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
   8.878 +    VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
   8.879 +    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
   8.880 +} VkSamplerMipmapMode;
   8.881 +
   8.882 +typedef enum VkSamplerAddressMode {
   8.883 +    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
   8.884 +    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
   8.885 +    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
   8.886 +    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
   8.887 +    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
   8.888 +    VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
   8.889 +    VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
   8.890 +    VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
   8.891 +    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
   8.892 +} VkSamplerAddressMode;
   8.893 +
   8.894 +typedef enum VkBorderColor {
   8.895 +    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
   8.896 +    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
   8.897 +    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
   8.898 +    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
   8.899 +    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
   8.900 +    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
   8.901 +    VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
   8.902 +    VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
   8.903 +    VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
   8.904 +    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
   8.905 +} VkBorderColor;
   8.906 +
   8.907 +typedef enum VkDescriptorType {
   8.908 +    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
   8.909 +    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
   8.910 +    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
   8.911 +    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
   8.912 +    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
   8.913 +    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
   8.914 +    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
   8.915 +    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
   8.916 +    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
   8.917 +    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
   8.918 +    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
   8.919 +    VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
   8.920 +    VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
   8.921 +    VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
   8.922 +    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.923 +} VkDescriptorType;
   8.924 +
   8.925 +typedef enum VkAttachmentLoadOp {
   8.926 +    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
   8.927 +    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
   8.928 +    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
   8.929 +    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
   8.930 +    VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   8.931 +    VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
   8.932 +    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
   8.933 +} VkAttachmentLoadOp;
   8.934 +
   8.935 +typedef enum VkAttachmentStoreOp {
   8.936 +    VK_ATTACHMENT_STORE_OP_STORE = 0,
   8.937 +    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
   8.938 +    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
   8.939 +    VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
   8.940 +    VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
   8.941 +    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
   8.942 +} VkAttachmentStoreOp;
   8.943 +
   8.944 +typedef enum VkPipelineBindPoint {
   8.945 +    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
   8.946 +    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
   8.947 +    VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
   8.948 +    VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
   8.949 +    VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
   8.950 +    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
   8.951 +} VkPipelineBindPoint;
   8.952 +
   8.953 +typedef enum VkCommandBufferLevel {
   8.954 +    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
   8.955 +    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
   8.956 +    VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
   8.957 +    VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
   8.958 +    VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
   8.959 +    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
   8.960 +} VkCommandBufferLevel;
   8.961 +
   8.962 +typedef enum VkIndexType {
   8.963 +    VK_INDEX_TYPE_UINT16 = 0,
   8.964 +    VK_INDEX_TYPE_UINT32 = 1,
   8.965 +    VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
   8.966 +    VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
   8.967 +    VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
   8.968 +    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
   8.969 +} VkIndexType;
   8.970 +
   8.971 +typedef enum VkSubpassContents {
   8.972 +    VK_SUBPASS_CONTENTS_INLINE = 0,
   8.973 +    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
   8.974 +    VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
   8.975 +    VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
   8.976 +    VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
   8.977 +    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
   8.978 +} VkSubpassContents;
   8.979 +
   8.980 +typedef enum VkObjectType {
   8.981 +    VK_OBJECT_TYPE_UNKNOWN = 0,
   8.982 +    VK_OBJECT_TYPE_INSTANCE = 1,
   8.983 +    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
   8.984 +    VK_OBJECT_TYPE_DEVICE = 3,
   8.985 +    VK_OBJECT_TYPE_QUEUE = 4,
   8.986 +    VK_OBJECT_TYPE_SEMAPHORE = 5,
   8.987 +    VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
   8.988 +    VK_OBJECT_TYPE_FENCE = 7,
   8.989 +    VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
   8.990 +    VK_OBJECT_TYPE_BUFFER = 9,
   8.991 +    VK_OBJECT_TYPE_IMAGE = 10,
   8.992 +    VK_OBJECT_TYPE_EVENT = 11,
   8.993 +    VK_OBJECT_TYPE_QUERY_POOL = 12,
   8.994 +    VK_OBJECT_TYPE_BUFFER_VIEW = 13,
   8.995 +    VK_OBJECT_TYPE_IMAGE_VIEW = 14,
   8.996 +    VK_OBJECT_TYPE_SHADER_MODULE = 15,
   8.997 +    VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
   8.998 +    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
   8.999 +    VK_OBJECT_TYPE_RENDER_PASS = 18,
  8.1000 +    VK_OBJECT_TYPE_PIPELINE = 19,
  8.1001 +    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
  8.1002 +    VK_OBJECT_TYPE_SAMPLER = 21,
  8.1003 +    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
  8.1004 +    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
  8.1005 +    VK_OBJECT_TYPE_FRAMEBUFFER = 24,
  8.1006 +    VK_OBJECT_TYPE_COMMAND_POOL = 25,
  8.1007 +    VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
  8.1008 +    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
  8.1009 +    VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
  8.1010 +    VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
  8.1011 +    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
  8.1012 +    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000,
  8.1013 +    VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
  8.1014 +    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
  8.1015 +    VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
  8.1016 +    VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
  8.1017 +    VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
  8.1018 +    VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
  8.1019 +} VkObjectType;
  8.1020 +
  8.1021 +typedef VkFlags VkInstanceCreateFlags;
  8.1022 +
  8.1023 +typedef enum VkFormatFeatureFlagBits {
  8.1024 +    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
  8.1025 +    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
  8.1026 +    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
  8.1027 +    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
  8.1028 +    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
  8.1029 +    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
  8.1030 +    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
  8.1031 +    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
  8.1032 +    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
  8.1033 +    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
  8.1034 +    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
  8.1035 +    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
  8.1036 +    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
  8.1037 +    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
  8.1038 +    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
  8.1039 +    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
  8.1040 +    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
  8.1041 +    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1042 +} VkFormatFeatureFlagBits;
  8.1043 +typedef VkFlags VkFormatFeatureFlags;
  8.1044 +
  8.1045 +typedef enum VkImageUsageFlagBits {
  8.1046 +    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
  8.1047 +    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
  8.1048 +    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
  8.1049 +    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
  8.1050 +    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
  8.1051 +    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
  8.1052 +    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
  8.1053 +    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
  8.1054 +    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1055 +} VkImageUsageFlagBits;
  8.1056 +typedef VkFlags VkImageUsageFlags;
  8.1057 +
  8.1058 +typedef enum VkImageCreateFlagBits {
  8.1059 +    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
  8.1060 +    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
  8.1061 +    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
  8.1062 +    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
  8.1063 +    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
  8.1064 +    VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
  8.1065 +    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
  8.1066 +    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1067 +} VkImageCreateFlagBits;
  8.1068 +typedef VkFlags VkImageCreateFlags;
  8.1069 +
  8.1070 +typedef enum VkSampleCountFlagBits {
  8.1071 +    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
  8.1072 +    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
  8.1073 +    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
  8.1074 +    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
  8.1075 +    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
  8.1076 +    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
  8.1077 +    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
  8.1078 +    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1079 +} VkSampleCountFlagBits;
  8.1080 +typedef VkFlags VkSampleCountFlags;
  8.1081 +
  8.1082 +typedef enum VkQueueFlagBits {
  8.1083 +    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
  8.1084 +    VK_QUEUE_COMPUTE_BIT = 0x00000002,
  8.1085 +    VK_QUEUE_TRANSFER_BIT = 0x00000004,
  8.1086 +    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
  8.1087 +    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1088 +} VkQueueFlagBits;
  8.1089 +typedef VkFlags VkQueueFlags;
  8.1090 +
  8.1091 +typedef enum VkMemoryPropertyFlagBits {
  8.1092 +    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
  8.1093 +    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
  8.1094 +    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
  8.1095 +    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
  8.1096 +    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
  8.1097 +    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1098 +} VkMemoryPropertyFlagBits;
  8.1099 +typedef VkFlags VkMemoryPropertyFlags;
  8.1100 +
  8.1101 +typedef enum VkMemoryHeapFlagBits {
  8.1102 +    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
  8.1103 +    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
  8.1104 +    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1105 +} VkMemoryHeapFlagBits;
  8.1106 +typedef VkFlags VkMemoryHeapFlags;
  8.1107 +typedef VkFlags VkDeviceCreateFlags;
  8.1108 +typedef VkFlags VkDeviceQueueCreateFlags;
  8.1109 +
  8.1110 +typedef enum VkPipelineStageFlagBits {
  8.1111 +    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
  8.1112 +    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
  8.1113 +    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
  8.1114 +    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
  8.1115 +    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
  8.1116 +    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
  8.1117 +    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
  8.1118 +    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
  8.1119 +    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
  8.1120 +    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
  8.1121 +    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
  8.1122 +    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
  8.1123 +    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
  8.1124 +    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
  8.1125 +    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
  8.1126 +    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
  8.1127 +    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
  8.1128 +    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
  8.1129 +    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1130 +} VkPipelineStageFlagBits;
  8.1131 +typedef VkFlags VkPipelineStageFlags;
  8.1132 +typedef VkFlags VkMemoryMapFlags;
  8.1133 +
  8.1134 +typedef enum VkImageAspectFlagBits {
  8.1135 +    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
  8.1136 +    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
  8.1137 +    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
  8.1138 +    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
  8.1139 +    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1140 +} VkImageAspectFlagBits;
  8.1141 +typedef VkFlags VkImageAspectFlags;
  8.1142 +
  8.1143 +typedef enum VkSparseImageFormatFlagBits {
  8.1144 +    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
  8.1145 +    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
  8.1146 +    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
  8.1147 +    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1148 +} VkSparseImageFormatFlagBits;
  8.1149 +typedef VkFlags VkSparseImageFormatFlags;
  8.1150 +
  8.1151 +typedef enum VkSparseMemoryBindFlagBits {
  8.1152 +    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
  8.1153 +    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1154 +} VkSparseMemoryBindFlagBits;
  8.1155 +typedef VkFlags VkSparseMemoryBindFlags;
  8.1156 +
  8.1157 +typedef enum VkFenceCreateFlagBits {
  8.1158 +    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
  8.1159 +    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1160 +} VkFenceCreateFlagBits;
  8.1161 +typedef VkFlags VkFenceCreateFlags;
  8.1162 +typedef VkFlags VkSemaphoreCreateFlags;
  8.1163 +typedef VkFlags VkEventCreateFlags;
  8.1164 +typedef VkFlags VkQueryPoolCreateFlags;
  8.1165 +
  8.1166 +typedef enum VkQueryPipelineStatisticFlagBits {
  8.1167 +    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
  8.1168 +    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
  8.1169 +    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
  8.1170 +    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
  8.1171 +    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
  8.1172 +    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
  8.1173 +    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
  8.1174 +    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
  8.1175 +    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
  8.1176 +    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
  8.1177 +    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
  8.1178 +    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1179 +} VkQueryPipelineStatisticFlagBits;
  8.1180 +typedef VkFlags VkQueryPipelineStatisticFlags;
  8.1181 +
  8.1182 +typedef enum VkQueryResultFlagBits {
  8.1183 +    VK_QUERY_RESULT_64_BIT = 0x00000001,
  8.1184 +    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
  8.1185 +    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
  8.1186 +    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
  8.1187 +    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1188 +} VkQueryResultFlagBits;
  8.1189 +typedef VkFlags VkQueryResultFlags;
  8.1190 +
  8.1191 +typedef enum VkBufferCreateFlagBits {
  8.1192 +    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
  8.1193 +    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
  8.1194 +    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
  8.1195 +    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1196 +} VkBufferCreateFlagBits;
  8.1197 +typedef VkFlags VkBufferCreateFlags;
  8.1198 +
  8.1199 +typedef enum VkBufferUsageFlagBits {
  8.1200 +    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
  8.1201 +    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
  8.1202 +    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
  8.1203 +    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
  8.1204 +    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
  8.1205 +    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
  8.1206 +    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
  8.1207 +    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
  8.1208 +    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
  8.1209 +    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1210 +} VkBufferUsageFlagBits;
  8.1211 +typedef VkFlags VkBufferUsageFlags;
  8.1212 +typedef VkFlags VkBufferViewCreateFlags;
  8.1213 +typedef VkFlags VkImageViewCreateFlags;
  8.1214 +typedef VkFlags VkShaderModuleCreateFlags;
  8.1215 +typedef VkFlags VkPipelineCacheCreateFlags;
  8.1216 +
  8.1217 +typedef enum VkPipelineCreateFlagBits {
  8.1218 +    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
  8.1219 +    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
  8.1220 +    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
  8.1221 +    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
  8.1222 +    VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
  8.1223 +    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1224 +} VkPipelineCreateFlagBits;
  8.1225 +typedef VkFlags VkPipelineCreateFlags;
  8.1226 +typedef VkFlags VkPipelineShaderStageCreateFlags;
  8.1227 +
  8.1228 +typedef enum VkShaderStageFlagBits {
  8.1229 +    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
  8.1230 +    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
  8.1231 +    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
  8.1232 +    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
  8.1233 +    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
  8.1234 +    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
  8.1235 +    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
  8.1236 +    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
  8.1237 +    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1238 +} VkShaderStageFlagBits;
  8.1239 +typedef VkFlags VkPipelineVertexInputStateCreateFlags;
  8.1240 +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
  8.1241 +typedef VkFlags VkPipelineTessellationStateCreateFlags;
  8.1242 +typedef VkFlags VkPipelineViewportStateCreateFlags;
  8.1243 +typedef VkFlags VkPipelineRasterizationStateCreateFlags;
  8.1244 +
  8.1245 +typedef enum VkCullModeFlagBits {
  8.1246 +    VK_CULL_MODE_NONE = 0,
  8.1247 +    VK_CULL_MODE_FRONT_BIT = 0x00000001,
  8.1248 +    VK_CULL_MODE_BACK_BIT = 0x00000002,
  8.1249 +    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
  8.1250 +    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1251 +} VkCullModeFlagBits;
  8.1252 +typedef VkFlags VkCullModeFlags;
  8.1253 +typedef VkFlags VkPipelineMultisampleStateCreateFlags;
  8.1254 +typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
  8.1255 +typedef VkFlags VkPipelineColorBlendStateCreateFlags;
  8.1256 +
  8.1257 +typedef enum VkColorComponentFlagBits {
  8.1258 +    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
  8.1259 +    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
  8.1260 +    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
  8.1261 +    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
  8.1262 +    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1263 +} VkColorComponentFlagBits;
  8.1264 +typedef VkFlags VkColorComponentFlags;
  8.1265 +typedef VkFlags VkPipelineDynamicStateCreateFlags;
  8.1266 +typedef VkFlags VkPipelineLayoutCreateFlags;
  8.1267 +typedef VkFlags VkShaderStageFlags;
  8.1268 +typedef VkFlags VkSamplerCreateFlags;
  8.1269 +
  8.1270 +typedef enum VkDescriptorSetLayoutCreateFlagBits {
  8.1271 +    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
  8.1272 +    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1273 +} VkDescriptorSetLayoutCreateFlagBits;
  8.1274 +typedef VkFlags VkDescriptorSetLayoutCreateFlags;
  8.1275 +
  8.1276 +typedef enum VkDescriptorPoolCreateFlagBits {
  8.1277 +    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
  8.1278 +    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1279 +} VkDescriptorPoolCreateFlagBits;
  8.1280 +typedef VkFlags VkDescriptorPoolCreateFlags;
  8.1281 +typedef VkFlags VkDescriptorPoolResetFlags;
  8.1282 +typedef VkFlags VkFramebufferCreateFlags;
  8.1283 +typedef VkFlags VkRenderPassCreateFlags;
  8.1284 +
  8.1285 +typedef enum VkAttachmentDescriptionFlagBits {
  8.1286 +    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
  8.1287 +    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1288 +} VkAttachmentDescriptionFlagBits;
  8.1289 +typedef VkFlags VkAttachmentDescriptionFlags;
  8.1290 +
  8.1291 +typedef enum VkSubpassDescriptionFlagBits {
  8.1292 +    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
  8.1293 +    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
  8.1294 +    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1295 +} VkSubpassDescriptionFlagBits;
  8.1296 +typedef VkFlags VkSubpassDescriptionFlags;
  8.1297 +
  8.1298 +typedef enum VkAccessFlagBits {
  8.1299 +    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
  8.1300 +    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
  8.1301 +    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
  8.1302 +    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
  8.1303 +    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
  8.1304 +    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
  8.1305 +    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
  8.1306 +    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
  8.1307 +    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
  8.1308 +    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
  8.1309 +    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
  8.1310 +    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
  8.1311 +    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
  8.1312 +    VK_ACCESS_HOST_READ_BIT = 0x00002000,
  8.1313 +    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
  8.1314 +    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
  8.1315 +    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
  8.1316 +    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
  8.1317 +    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
  8.1318 +    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
  8.1319 +    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1320 +} VkAccessFlagBits;
  8.1321 +typedef VkFlags VkAccessFlags;
  8.1322 +
  8.1323 +typedef enum VkDependencyFlagBits {
  8.1324 +    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
  8.1325 +    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
  8.1326 +    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
  8.1327 +    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1328 +} VkDependencyFlagBits;
  8.1329 +typedef VkFlags VkDependencyFlags;
  8.1330 +
  8.1331 +typedef enum VkCommandPoolCreateFlagBits {
  8.1332 +    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
  8.1333 +    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
  8.1334 +    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1335 +} VkCommandPoolCreateFlagBits;
  8.1336 +typedef VkFlags VkCommandPoolCreateFlags;
  8.1337 +
  8.1338 +typedef enum VkCommandPoolResetFlagBits {
  8.1339 +    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
  8.1340 +    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1341 +} VkCommandPoolResetFlagBits;
  8.1342 +typedef VkFlags VkCommandPoolResetFlags;
  8.1343 +
  8.1344 +typedef enum VkCommandBufferUsageFlagBits {
  8.1345 +    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
  8.1346 +    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
  8.1347 +    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
  8.1348 +    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1349 +} VkCommandBufferUsageFlagBits;
  8.1350 +typedef VkFlags VkCommandBufferUsageFlags;
  8.1351 +
  8.1352 +typedef enum VkQueryControlFlagBits {
  8.1353 +    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
  8.1354 +    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1355 +} VkQueryControlFlagBits;
  8.1356 +typedef VkFlags VkQueryControlFlags;
  8.1357 +
  8.1358 +typedef enum VkCommandBufferResetFlagBits {
  8.1359 +    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
  8.1360 +    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1361 +} VkCommandBufferResetFlagBits;
  8.1362 +typedef VkFlags VkCommandBufferResetFlags;
  8.1363 +
  8.1364 +typedef enum VkStencilFaceFlagBits {
  8.1365 +    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
  8.1366 +    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
  8.1367 +    VK_STENCIL_FRONT_AND_BACK = 0x00000003,
  8.1368 +    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  8.1369 +} VkStencilFaceFlagBits;
  8.1370 +typedef VkFlags VkStencilFaceFlags;
  8.1371 +
  8.1372 +typedef struct VkApplicationInfo {
  8.1373 +    VkStructureType    sType;
  8.1374 +    const void*        pNext;
  8.1375 +    const char*        pApplicationName;
  8.1376 +    uint32_t           applicationVersion;
  8.1377 +    const char*        pEngineName;
  8.1378 +    uint32_t           engineVersion;
  8.1379 +    uint32_t           apiVersion;
  8.1380 +} VkApplicationInfo;
  8.1381 +
  8.1382 +typedef struct VkInstanceCreateInfo {
  8.1383 +    VkStructureType             sType;
  8.1384 +    const void*                 pNext;
  8.1385 +    VkInstanceCreateFlags       flags;
  8.1386 +    const VkApplicationInfo*    pApplicationInfo;
  8.1387 +    uint32_t                    enabledLayerCount;
  8.1388 +    const char* const*          ppEnabledLayerNames;
  8.1389 +    uint32_t                    enabledExtensionCount;
  8.1390 +    const char* const*          ppEnabledExtensionNames;
  8.1391 +} VkInstanceCreateInfo;
  8.1392 +
  8.1393 +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
  8.1394 +    void*                                       pUserData,
  8.1395 +    size_t                                      size,
  8.1396 +    size_t                                      alignment,
  8.1397 +    VkSystemAllocationScope                     allocationScope);
  8.1398 +
  8.1399 +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
  8.1400 +    void*                                       pUserData,
  8.1401 +    void*                                       pOriginal,
  8.1402 +    size_t                                      size,
  8.1403 +    size_t                                      alignment,
  8.1404 +    VkSystemAllocationScope                     allocationScope);
  8.1405 +
  8.1406 +typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
  8.1407 +    void*                                       pUserData,
  8.1408 +    void*                                       pMemory);
  8.1409 +
  8.1410 +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
  8.1411 +    void*                                       pUserData,
  8.1412 +    size_t                                      size,
  8.1413 +    VkInternalAllocationType                    allocationType,
  8.1414 +    VkSystemAllocationScope                     allocationScope);
  8.1415 +
  8.1416 +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
  8.1417 +    void*                                       pUserData,
  8.1418 +    size_t                                      size,
  8.1419 +    VkInternalAllocationType                    allocationType,
  8.1420 +    VkSystemAllocationScope                     allocationScope);
  8.1421 +
  8.1422 +typedef struct VkAllocationCallbacks {
  8.1423 +    void*                                   pUserData;
  8.1424 +    PFN_vkAllocationFunction                pfnAllocation;
  8.1425 +    PFN_vkReallocationFunction              pfnReallocation;
  8.1426 +    PFN_vkFreeFunction                      pfnFree;
  8.1427 +    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
  8.1428 +    PFN_vkInternalFreeNotification          pfnInternalFree;
  8.1429 +} VkAllocationCallbacks;
  8.1430 +
  8.1431 +typedef struct VkPhysicalDeviceFeatures {
  8.1432 +    VkBool32    robustBufferAccess;
  8.1433 +    VkBool32    fullDrawIndexUint32;
  8.1434 +    VkBool32    imageCubeArray;
  8.1435 +    VkBool32    independentBlend;
  8.1436 +    VkBool32    geometryShader;
  8.1437 +    VkBool32    tessellationShader;
  8.1438 +    VkBool32    sampleRateShading;
  8.1439 +    VkBool32    dualSrcBlend;
  8.1440 +    VkBool32    logicOp;
  8.1441 +    VkBool32    multiDrawIndirect;
  8.1442 +    VkBool32    drawIndirectFirstInstance;
  8.1443 +    VkBool32    depthClamp;
  8.1444 +    VkBool32    depthBiasClamp;
  8.1445 +    VkBool32    fillModeNonSolid;
  8.1446 +    VkBool32    depthBounds;
  8.1447 +    VkBool32    wideLines;
  8.1448 +    VkBool32    largePoints;
  8.1449 +    VkBool32    alphaToOne;
  8.1450 +    VkBool32    multiViewport;
  8.1451 +    VkBool32    samplerAnisotropy;
  8.1452 +    VkBool32    textureCompressionETC2;
  8.1453 +    VkBool32    textureCompressionASTC_LDR;
  8.1454 +    VkBool32    textureCompressionBC;
  8.1455 +    VkBool32    occlusionQueryPrecise;
  8.1456 +    VkBool32    pipelineStatisticsQuery;
  8.1457 +    VkBool32    vertexPipelineStoresAndAtomics;
  8.1458 +    VkBool32    fragmentStoresAndAtomics;
  8.1459 +    VkBool32    shaderTessellationAndGeometryPointSize;
  8.1460 +    VkBool32    shaderImageGatherExtended;
  8.1461 +    VkBool32    shaderStorageImageExtendedFormats;
  8.1462 +    VkBool32    shaderStorageImageMultisample;
  8.1463 +    VkBool32    shaderStorageImageReadWithoutFormat;
  8.1464 +    VkBool32    shaderStorageImageWriteWithoutFormat;
  8.1465 +    VkBool32    shaderUniformBufferArrayDynamicIndexing;
  8.1466 +    VkBool32    shaderSampledImageArrayDynamicIndexing;
  8.1467 +    VkBool32    shaderStorageBufferArrayDynamicIndexing;
  8.1468 +    VkBool32    shaderStorageImageArrayDynamicIndexing;
  8.1469 +    VkBool32    shaderClipDistance;
  8.1470 +    VkBool32    shaderCullDistance;
  8.1471 +    VkBool32    shaderFloat64;
  8.1472 +    VkBool32    shaderInt64;
  8.1473 +    VkBool32    shaderInt16;
  8.1474 +    VkBool32    shaderResourceResidency;
  8.1475 +    VkBool32    shaderResourceMinLod;
  8.1476 +    VkBool32    sparseBinding;
  8.1477 +    VkBool32    sparseResidencyBuffer;
  8.1478 +    VkBool32    sparseResidencyImage2D;
  8.1479 +    VkBool32    sparseResidencyImage3D;
  8.1480 +    VkBool32    sparseResidency2Samples;
  8.1481 +    VkBool32    sparseResidency4Samples;
  8.1482 +    VkBool32    sparseResidency8Samples;
  8.1483 +    VkBool32    sparseResidency16Samples;
  8.1484 +    VkBool32    sparseResidencyAliased;
  8.1485 +    VkBool32    variableMultisampleRate;
  8.1486 +    VkBool32    inheritedQueries;
  8.1487 +} VkPhysicalDeviceFeatures;
  8.1488 +
  8.1489 +typedef struct VkFormatProperties {
  8.1490 +    VkFormatFeatureFlags    linearTilingFeatures;
  8.1491 +    VkFormatFeatureFlags    optimalTilingFeatures;
  8.1492 +    VkFormatFeatureFlags    bufferFeatures;
  8.1493 +} VkFormatProperties;
  8.1494 +
  8.1495 +typedef struct VkExtent3D {
  8.1496 +    uint32_t    width;
  8.1497 +    uint32_t    height;
  8.1498 +    uint32_t    depth;
  8.1499 +} VkExtent3D;
  8.1500 +
  8.1501 +typedef struct VkImageFormatProperties {
  8.1502 +    VkExtent3D            maxExtent;
  8.1503 +    uint32_t              maxMipLevels;
  8.1504 +    uint32_t              maxArrayLayers;
  8.1505 +    VkSampleCountFlags    sampleCounts;
  8.1506 +    VkDeviceSize          maxResourceSize;
  8.1507 +} VkImageFormatProperties;
  8.1508 +
  8.1509 +typedef struct VkPhysicalDeviceLimits {
  8.1510 +    uint32_t              maxImageDimension1D;
  8.1511 +    uint32_t              maxImageDimension2D;
  8.1512 +    uint32_t              maxImageDimension3D;
  8.1513 +    uint32_t              maxImageDimensionCube;
  8.1514 +    uint32_t              maxImageArrayLayers;
  8.1515 +    uint32_t              maxTexelBufferElements;
  8.1516 +    uint32_t              maxUniformBufferRange;
  8.1517 +    uint32_t              maxStorageBufferRange;
  8.1518 +    uint32_t              maxPushConstantsSize;
  8.1519 +    uint32_t              maxMemoryAllocationCount;
  8.1520 +    uint32_t              maxSamplerAllocationCount;
  8.1521 +    VkDeviceSize          bufferImageGranularity;
  8.1522 +    VkDeviceSize          sparseAddressSpaceSize;
  8.1523 +    uint32_t              maxBoundDescriptorSets;
  8.1524 +    uint32_t              maxPerStageDescriptorSamplers;
  8.1525 +    uint32_t              maxPerStageDescriptorUniformBuffers;
  8.1526 +    uint32_t              maxPerStageDescriptorStorageBuffers;
  8.1527 +    uint32_t              maxPerStageDescriptorSampledImages;
  8.1528 +    uint32_t              maxPerStageDescriptorStorageImages;
  8.1529 +    uint32_t              maxPerStageDescriptorInputAttachments;
  8.1530 +    uint32_t              maxPerStageResources;
  8.1531 +    uint32_t              maxDescriptorSetSamplers;
  8.1532 +    uint32_t              maxDescriptorSetUniformBuffers;
  8.1533 +    uint32_t              maxDescriptorSetUniformBuffersDynamic;
  8.1534 +    uint32_t              maxDescriptorSetStorageBuffers;
  8.1535 +    uint32_t              maxDescriptorSetStorageBuffersDynamic;
  8.1536 +    uint32_t              maxDescriptorSetSampledImages;
  8.1537 +    uint32_t              maxDescriptorSetStorageImages;
  8.1538 +    uint32_t              maxDescriptorSetInputAttachments;
  8.1539 +    uint32_t              maxVertexInputAttributes;
  8.1540 +    uint32_t              maxVertexInputBindings;
  8.1541 +    uint32_t              maxVertexInputAttributeOffset;
  8.1542 +    uint32_t              maxVertexInputBindingStride;
  8.1543 +    uint32_t              maxVertexOutputComponents;
  8.1544 +    uint32_t              maxTessellationGenerationLevel;
  8.1545 +    uint32_t              maxTessellationPatchSize;
  8.1546 +    uint32_t              maxTessellationControlPerVertexInputComponents;
  8.1547 +    uint32_t              maxTessellationControlPerVertexOutputComponents;
  8.1548 +    uint32_t              maxTessellationControlPerPatchOutputComponents;
  8.1549 +    uint32_t              maxTessellationControlTotalOutputComponents;
  8.1550 +    uint32_t              maxTessellationEvaluationInputComponents;
  8.1551 +    uint32_t              maxTessellationEvaluationOutputComponents;
  8.1552 +    uint32_t              maxGeometryShaderInvocations;
  8.1553 +    uint32_t              maxGeometryInputComponents;
  8.1554 +    uint32_t              maxGeometryOutputComponents;
  8.1555 +    uint32_t              maxGeometryOutputVertices;
  8.1556 +    uint32_t              maxGeometryTotalOutputComponents;
  8.1557 +    uint32_t              maxFragmentInputComponents;
  8.1558 +    uint32_t              maxFragmentOutputAttachments;
  8.1559 +    uint32_t              maxFragmentDualSrcAttachments;
  8.1560 +    uint32_t              maxFragmentCombinedOutputResources;
  8.1561 +    uint32_t              maxComputeSharedMemorySize;
  8.1562 +    uint32_t              maxComputeWorkGroupCount[3];
  8.1563 +    uint32_t              maxComputeWorkGroupInvocations;
  8.1564 +    uint32_t              maxComputeWorkGroupSize[3];
  8.1565 +    uint32_t              subPixelPrecisionBits;
  8.1566 +    uint32_t              subTexelPrecisionBits;
  8.1567 +    uint32_t              mipmapPrecisionBits;
  8.1568 +    uint32_t              maxDrawIndexedIndexValue;
  8.1569 +    uint32_t              maxDrawIndirectCount;
  8.1570 +    float                 maxSamplerLodBias;
  8.1571 +    float                 maxSamplerAnisotropy;
  8.1572 +    uint32_t              maxViewports;
  8.1573 +    uint32_t              maxViewportDimensions[2];
  8.1574 +    float                 viewportBoundsRange[2];
  8.1575 +    uint32_t              viewportSubPixelBits;
  8.1576 +    size_t                minMemoryMapAlignment;
  8.1577 +    VkDeviceSize          minTexelBufferOffsetAlignment;
  8.1578 +    VkDeviceSize          minUniformBufferOffsetAlignment;
  8.1579 +    VkDeviceSize          minStorageBufferOffsetAlignment;
  8.1580 +    int32_t               minTexelOffset;
  8.1581 +    uint32_t              maxTexelOffset;
  8.1582 +    int32_t               minTexelGatherOffset;
  8.1583 +    uint32_t              maxTexelGatherOffset;
  8.1584 +    float                 minInterpolationOffset;
  8.1585 +    float                 maxInterpolationOffset;
  8.1586 +    uint32_t              subPixelInterpolationOffsetBits;
  8.1587 +    uint32_t              maxFramebufferWidth;
  8.1588 +    uint32_t              maxFramebufferHeight;
  8.1589 +    uint32_t              maxFramebufferLayers;
  8.1590 +    VkSampleCountFlags    framebufferColorSampleCounts;
  8.1591 +    VkSampleCountFlags    framebufferDepthSampleCounts;
  8.1592 +    VkSampleCountFlags    framebufferStencilSampleCounts;
  8.1593 +    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
  8.1594 +    uint32_t              maxColorAttachments;
  8.1595 +    VkSampleCountFlags    sampledImageColorSampleCounts;
  8.1596 +    VkSampleCountFlags    sampledImageIntegerSampleCounts;
  8.1597 +    VkSampleCountFlags    sampledImageDepthSampleCounts;
  8.1598 +    VkSampleCountFlags    sampledImageStencilSampleCounts;
  8.1599 +    VkSampleCountFlags    storageImageSampleCounts;
  8.1600 +    uint32_t              maxSampleMaskWords;
  8.1601 +    VkBool32              timestampComputeAndGraphics;
  8.1602 +    float                 timestampPeriod;
  8.1603 +    uint32_t              maxClipDistances;
  8.1604 +    uint32_t              maxCullDistances;
  8.1605 +    uint32_t              maxCombinedClipAndCullDistances;
  8.1606 +    uint32_t              discreteQueuePriorities;
  8.1607 +    float                 pointSizeRange[2];
  8.1608 +    float                 lineWidthRange[2];
  8.1609 +    float                 pointSizeGranularity;
  8.1610 +    float                 lineWidthGranularity;
  8.1611 +    VkBool32              strictLines;
  8.1612 +    VkBool32              standardSampleLocations;
  8.1613 +    VkDeviceSize          optimalBufferCopyOffsetAlignment;
  8.1614 +    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
  8.1615 +    VkDeviceSize          nonCoherentAtomSize;
  8.1616 +} VkPhysicalDeviceLimits;
  8.1617 +
  8.1618 +typedef struct VkPhysicalDeviceSparseProperties {
  8.1619 +    VkBool32    residencyStandard2DBlockShape;
  8.1620 +    VkBool32    residencyStandard2DMultisampleBlockShape;
  8.1621 +    VkBool32    residencyStandard3DBlockShape;
  8.1622 +    VkBool32    residencyAlignedMipSize;
  8.1623 +    VkBool32    residencyNonResidentStrict;
  8.1624 +} VkPhysicalDeviceSparseProperties;
  8.1625 +
  8.1626 +typedef struct VkPhysicalDeviceProperties {
  8.1627 +    uint32_t                            apiVersion;
  8.1628 +    uint32_t                            driverVersion;
  8.1629 +    uint32_t                            vendorID;
  8.1630 +    uint32_t                            deviceID;
  8.1631 +    VkPhysicalDeviceType                deviceType;
  8.1632 +    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
  8.1633 +    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
  8.1634 +    VkPhysicalDeviceLimits              limits;
  8.1635 +    VkPhysicalDeviceSparseProperties    sparseProperties;
  8.1636 +} VkPhysicalDeviceProperties;
  8.1637 +
  8.1638 +typedef struct VkQueueFamilyProperties {
  8.1639 +    VkQueueFlags    queueFlags;
  8.1640 +    uint32_t        queueCount;
  8.1641 +    uint32_t        timestampValidBits;
  8.1642 +    VkExtent3D      minImageTransferGranularity;
  8.1643 +} VkQueueFamilyProperties;
  8.1644 +
  8.1645 +typedef struct VkMemoryType {
  8.1646 +    VkMemoryPropertyFlags    propertyFlags;
  8.1647 +    uint32_t                 heapIndex;
  8.1648 +} VkMemoryType;
  8.1649 +
  8.1650 +typedef struct VkMemoryHeap {
  8.1651 +    VkDeviceSize         size;
  8.1652 +    VkMemoryHeapFlags    flags;
  8.1653 +} VkMemoryHeap;
  8.1654 +
  8.1655 +typedef struct VkPhysicalDeviceMemoryProperties {
  8.1656 +    uint32_t        memoryTypeCount;
  8.1657 +    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
  8.1658 +    uint32_t        memoryHeapCount;
  8.1659 +    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
  8.1660 +} VkPhysicalDeviceMemoryProperties;
  8.1661 +
  8.1662 +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
  8.1663 +typedef struct VkDeviceQueueCreateInfo {
  8.1664 +    VkStructureType             sType;
  8.1665 +    const void*                 pNext;
  8.1666 +    VkDeviceQueueCreateFlags    flags;
  8.1667 +    uint32_t                    queueFamilyIndex;
  8.1668 +    uint32_t                    queueCount;
  8.1669 +    const float*                pQueuePriorities;
  8.1670 +} VkDeviceQueueCreateInfo;
  8.1671 +
  8.1672 +typedef struct VkDeviceCreateInfo {
  8.1673 +    VkStructureType                    sType;
  8.1674 +    const void*                        pNext;
  8.1675 +    VkDeviceCreateFlags                flags;
  8.1676 +    uint32_t                           queueCreateInfoCount;
  8.1677 +    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
  8.1678 +    uint32_t                           enabledLayerCount;
  8.1679 +    const char* const*                 ppEnabledLayerNames;
  8.1680 +    uint32_t                           enabledExtensionCount;
  8.1681 +    const char* const*                 ppEnabledExtensionNames;
  8.1682 +    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
  8.1683 +} VkDeviceCreateInfo;
  8.1684 +
  8.1685 +typedef struct VkExtensionProperties {
  8.1686 +    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
  8.1687 +    uint32_t    specVersion;
  8.1688 +} VkExtensionProperties;
  8.1689 +
  8.1690 +typedef struct VkLayerProperties {
  8.1691 +    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
  8.1692 +    uint32_t    specVersion;
  8.1693 +    uint32_t    implementationVersion;
  8.1694 +    char        description[VK_MAX_DESCRIPTION_SIZE];
  8.1695 +} VkLayerProperties;
  8.1696 +
  8.1697 +typedef struct VkSubmitInfo {
  8.1698 +    VkStructureType                sType;
  8.1699 +    const void*                    pNext;
  8.1700 +    uint32_t                       waitSemaphoreCount;
  8.1701 +    const VkSemaphore*             pWaitSemaphores;
  8.1702 +    const VkPipelineStageFlags*    pWaitDstStageMask;
  8.1703 +    uint32_t                       commandBufferCount;
  8.1704 +    const VkCommandBuffer*         pCommandBuffers;
  8.1705 +    uint32_t                       signalSemaphoreCount;
  8.1706 +    const VkSemaphore*             pSignalSemaphores;
  8.1707 +} VkSubmitInfo;
  8.1708 +
  8.1709 +typedef struct VkMemoryAllocateInfo {
  8.1710 +    VkStructureType    sType;
  8.1711 +    const void*        pNext;
  8.1712 +    VkDeviceSize       allocationSize;
  8.1713 +    uint32_t           memoryTypeIndex;
  8.1714 +} VkMemoryAllocateInfo;
  8.1715 +
  8.1716 +typedef struct VkMappedMemoryRange {
  8.1717 +    VkStructureType    sType;
  8.1718 +    const void*        pNext;
  8.1719 +    VkDeviceMemory     memory;
  8.1720 +    VkDeviceSize       offset;
  8.1721 +    VkDeviceSize       size;
  8.1722 +} VkMappedMemoryRange;
  8.1723 +
  8.1724 +typedef struct VkMemoryRequirements {
  8.1725 +    VkDeviceSize    size;
  8.1726 +    VkDeviceSize    alignment;
  8.1727 +    uint32_t        memoryTypeBits;
  8.1728 +} VkMemoryRequirements;
  8.1729 +
  8.1730 +typedef struct VkSparseImageFormatProperties {
  8.1731 +    VkImageAspectFlags          aspectMask;
  8.1732 +    VkExtent3D                  imageGranularity;
  8.1733 +    VkSparseImageFormatFlags    flags;
  8.1734 +} VkSparseImageFormatProperties;
  8.1735 +
  8.1736 +typedef struct VkSparseImageMemoryRequirements {
  8.1737 +    VkSparseImageFormatProperties    formatProperties;
  8.1738 +    uint32_t                         imageMipTailFirstLod;
  8.1739 +    VkDeviceSize                     imageMipTailSize;
  8.1740 +    VkDeviceSize                     imageMipTailOffset;
  8.1741 +    VkDeviceSize                     imageMipTailStride;
  8.1742 +} VkSparseImageMemoryRequirements;
  8.1743 +
  8.1744 +typedef struct VkSparseMemoryBind {
  8.1745 +    VkDeviceSize               resourceOffset;
  8.1746 +    VkDeviceSize               size;
  8.1747 +    VkDeviceMemory             memory;
  8.1748 +    VkDeviceSize               memoryOffset;
  8.1749 +    VkSparseMemoryBindFlags    flags;
  8.1750 +} VkSparseMemoryBind;
  8.1751 +
  8.1752 +typedef struct VkSparseBufferMemoryBindInfo {
  8.1753 +    VkBuffer                     buffer;
  8.1754 +    uint32_t                     bindCount;
  8.1755 +    const VkSparseMemoryBind*    pBinds;
  8.1756 +} VkSparseBufferMemoryBindInfo;
  8.1757 +
  8.1758 +typedef struct VkSparseImageOpaqueMemoryBindInfo {
  8.1759 +    VkImage                      image;
  8.1760 +    uint32_t                     bindCount;
  8.1761 +    const VkSparseMemoryBind*    pBinds;
  8.1762 +} VkSparseImageOpaqueMemoryBindInfo;
  8.1763 +
  8.1764 +typedef struct VkImageSubresource {
  8.1765 +    VkImageAspectFlags    aspectMask;
  8.1766 +    uint32_t              mipLevel;
  8.1767 +    uint32_t              arrayLayer;
  8.1768 +} VkImageSubresource;
  8.1769 +
  8.1770 +typedef struct VkOffset3D {
  8.1771 +    int32_t    x;
  8.1772 +    int32_t    y;
  8.1773 +    int32_t    z;
  8.1774 +} VkOffset3D;
  8.1775 +
  8.1776 +typedef struct VkSparseImageMemoryBind {
  8.1777 +    VkImageSubresource         subresource;
  8.1778 +    VkOffset3D                 offset;
  8.1779 +    VkExtent3D                 extent;
  8.1780 +    VkDeviceMemory             memory;
  8.1781 +    VkDeviceSize               memoryOffset;
  8.1782 +    VkSparseMemoryBindFlags    flags;
  8.1783 +} VkSparseImageMemoryBind;
  8.1784 +
  8.1785 +typedef struct VkSparseImageMemoryBindInfo {
  8.1786 +    VkImage                           image;
  8.1787 +    uint32_t                          bindCount;
  8.1788 +    const VkSparseImageMemoryBind*    pBinds;
  8.1789 +} VkSparseImageMemoryBindInfo;
  8.1790 +
  8.1791 +typedef struct VkBindSparseInfo {
  8.1792 +    VkStructureType                             sType;
  8.1793 +    const void*                                 pNext;
  8.1794 +    uint32_t                                    waitSemaphoreCount;
  8.1795 +    const VkSemaphore*                          pWaitSemaphores;
  8.1796 +    uint32_t                                    bufferBindCount;
  8.1797 +    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
  8.1798 +    uint32_t                                    imageOpaqueBindCount;
  8.1799 +    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
  8.1800 +    uint32_t                                    imageBindCount;
  8.1801 +    const VkSparseImageMemoryBindInfo*          pImageBinds;
  8.1802 +    uint32_t                                    signalSemaphoreCount;
  8.1803 +    const VkSemaphore*                          pSignalSemaphores;
  8.1804 +} VkBindSparseInfo;
  8.1805 +
  8.1806 +typedef struct VkFenceCreateInfo {
  8.1807 +    VkStructureType       sType;
  8.1808 +    const void*           pNext;
  8.1809 +    VkFenceCreateFlags    flags;
  8.1810 +} VkFenceCreateInfo;
  8.1811 +
  8.1812 +typedef struct VkSemaphoreCreateInfo {
  8.1813 +    VkStructureType           sType;
  8.1814 +    const void*               pNext;
  8.1815 +    VkSemaphoreCreateFlags    flags;
  8.1816 +} VkSemaphoreCreateInfo;
  8.1817 +
  8.1818 +typedef struct VkEventCreateInfo {
  8.1819 +    VkStructureType       sType;
  8.1820 +    const void*           pNext;
  8.1821 +    VkEventCreateFlags    flags;
  8.1822 +} VkEventCreateInfo;
  8.1823 +
  8.1824 +typedef struct VkQueryPoolCreateInfo {
  8.1825 +    VkStructureType                  sType;
  8.1826 +    const void*                      pNext;
  8.1827 +    VkQueryPoolCreateFlags           flags;
  8.1828 +    VkQueryType                      queryType;
  8.1829 +    uint32_t                         queryCount;
  8.1830 +    VkQueryPipelineStatisticFlags    pipelineStatistics;
  8.1831 +} VkQueryPoolCreateInfo;
  8.1832 +
  8.1833 +typedef struct VkBufferCreateInfo {
  8.1834 +    VkStructureType        sType;
  8.1835 +    const void*            pNext;
  8.1836 +    VkBufferCreateFlags    flags;
  8.1837 +    VkDeviceSize           size;
  8.1838 +    VkBufferUsageFlags     usage;
  8.1839 +    VkSharingMode          sharingMode;
  8.1840 +    uint32_t               queueFamilyIndexCount;
  8.1841 +    const uint32_t*        pQueueFamilyIndices;
  8.1842 +} VkBufferCreateInfo;
  8.1843 +
  8.1844 +typedef struct VkBufferViewCreateInfo {
  8.1845 +    VkStructureType            sType;
  8.1846 +    const void*                pNext;
  8.1847 +    VkBufferViewCreateFlags    flags;
  8.1848 +    VkBuffer                   buffer;
  8.1849 +    VkFormat                   format;
  8.1850 +    VkDeviceSize               offset;
  8.1851 +    VkDeviceSize               range;
  8.1852 +} VkBufferViewCreateInfo;
  8.1853 +
  8.1854 +typedef struct VkImageCreateInfo {
  8.1855 +    VkStructureType          sType;
  8.1856 +    const void*              pNext;
  8.1857 +    VkImageCreateFlags       flags;
  8.1858 +    VkImageType              imageType;
  8.1859 +    VkFormat                 format;
  8.1860 +    VkExtent3D               extent;
  8.1861 +    uint32_t                 mipLevels;
  8.1862 +    uint32_t                 arrayLayers;
  8.1863 +    VkSampleCountFlagBits    samples;
  8.1864 +    VkImageTiling            tiling;
  8.1865 +    VkImageUsageFlags        usage;
  8.1866 +    VkSharingMode            sharingMode;
  8.1867 +    uint32_t                 queueFamilyIndexCount;
  8.1868 +    const uint32_t*          pQueueFamilyIndices;
  8.1869 +    VkImageLayout            initialLayout;
  8.1870 +} VkImageCreateInfo;
  8.1871 +
  8.1872 +typedef struct VkSubresourceLayout {
  8.1873 +    VkDeviceSize    offset;
  8.1874 +    VkDeviceSize    size;
  8.1875 +    VkDeviceSize    rowPitch;
  8.1876 +    VkDeviceSize    arrayPitch;
  8.1877 +    VkDeviceSize    depthPitch;
  8.1878 +} VkSubresourceLayout;
  8.1879 +
  8.1880 +typedef struct VkComponentMapping {
  8.1881 +    VkComponentSwizzle    r;
  8.1882 +    VkComponentSwizzle    g;
  8.1883 +    VkComponentSwizzle    b;
  8.1884 +    VkComponentSwizzle    a;
  8.1885 +} VkComponentMapping;
  8.1886 +
  8.1887 +typedef struct VkImageSubresourceRange {
  8.1888 +    VkImageAspectFlags    aspectMask;
  8.1889 +    uint32_t              baseMipLevel;
  8.1890 +    uint32_t              levelCount;
  8.1891 +    uint32_t              baseArrayLayer;
  8.1892 +    uint32_t              layerCount;
  8.1893 +} VkImageSubresourceRange;
  8.1894 +
  8.1895 +typedef struct VkImageViewCreateInfo {
  8.1896 +    VkStructureType            sType;
  8.1897 +    const void*                pNext;
  8.1898 +    VkImageViewCreateFlags     flags;
  8.1899 +    VkImage                    image;
  8.1900 +    VkImageViewType            viewType;
  8.1901 +    VkFormat                   format;
  8.1902 +    VkComponentMapping         components;
  8.1903 +    VkImageSubresourceRange    subresourceRange;
  8.1904 +} VkImageViewCreateInfo;
  8.1905 +
  8.1906 +typedef struct VkShaderModuleCreateInfo {
  8.1907 +    VkStructureType              sType;
  8.1908 +    const void*                  pNext;
  8.1909 +    VkShaderModuleCreateFlags    flags;
  8.1910 +    size_t                       codeSize;
  8.1911 +    const uint32_t*              pCode;
  8.1912 +} VkShaderModuleCreateInfo;
  8.1913 +
  8.1914 +typedef struct VkPipelineCacheCreateInfo {
  8.1915 +    VkStructureType               sType;
  8.1916 +    const void*                   pNext;
  8.1917 +    VkPipelineCacheCreateFlags    flags;
  8.1918 +    size_t                        initialDataSize;
  8.1919 +    const void*                   pInitialData;
  8.1920 +} VkPipelineCacheCreateInfo;
  8.1921 +
  8.1922 +typedef struct VkSpecializationMapEntry {
  8.1923 +    uint32_t    constantID;
  8.1924 +    uint32_t    offset;
  8.1925 +    size_t      size;
  8.1926 +} VkSpecializationMapEntry;
  8.1927 +
  8.1928 +typedef struct VkSpecializationInfo {
  8.1929 +    uint32_t                           mapEntryCount;
  8.1930 +    const VkSpecializationMapEntry*    pMapEntries;
  8.1931 +    size_t                             dataSize;
  8.1932 +    const void*                        pData;
  8.1933 +} VkSpecializationInfo;
  8.1934 +
  8.1935 +typedef struct VkPipelineShaderStageCreateInfo {
  8.1936 +    VkStructureType                     sType;
  8.1937 +    const void*                         pNext;
  8.1938 +    VkPipelineShaderStageCreateFlags    flags;
  8.1939 +    VkShaderStageFlagBits               stage;
  8.1940 +    VkShaderModule                      module;
  8.1941 +    const char*                         pName;
  8.1942 +    const VkSpecializationInfo*         pSpecializationInfo;
  8.1943 +} VkPipelineShaderStageCreateInfo;
  8.1944 +
  8.1945 +typedef struct VkVertexInputBindingDescription {
  8.1946 +    uint32_t             binding;
  8.1947 +    uint32_t             stride;
  8.1948 +    VkVertexInputRate    inputRate;
  8.1949 +} VkVertexInputBindingDescription;
  8.1950 +
  8.1951 +typedef struct VkVertexInputAttributeDescription {
  8.1952 +    uint32_t    location;
  8.1953 +    uint32_t    binding;
  8.1954 +    VkFormat    format;
  8.1955 +    uint32_t    offset;
  8.1956 +} VkVertexInputAttributeDescription;
  8.1957 +
  8.1958 +typedef struct VkPipelineVertexInputStateCreateInfo {
  8.1959 +    VkStructureType                             sType;
  8.1960 +    const void*                                 pNext;
  8.1961 +    VkPipelineVertexInputStateCreateFlags       flags;
  8.1962 +    uint32_t                                    vertexBindingDescriptionCount;
  8.1963 +    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
  8.1964 +    uint32_t                                    vertexAttributeDescriptionCount;
  8.1965 +    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
  8.1966 +} VkPipelineVertexInputStateCreateInfo;
  8.1967 +
  8.1968 +typedef struct VkPipelineInputAssemblyStateCreateInfo {
  8.1969 +    VkStructureType                            sType;
  8.1970 +    const void*                                pNext;
  8.1971 +    VkPipelineInputAssemblyStateCreateFlags    flags;
  8.1972 +    VkPrimitiveTopology                        topology;
  8.1973 +    VkBool32                                   primitiveRestartEnable;
  8.1974 +} VkPipelineInputAssemblyStateCreateInfo;
  8.1975 +
  8.1976 +typedef struct VkPipelineTessellationStateCreateInfo {
  8.1977 +    VkStructureType                           sType;
  8.1978 +    const void*                               pNext;
  8.1979 +    VkPipelineTessellationStateCreateFlags    flags;
  8.1980 +    uint32_t                                  patchControlPoints;
  8.1981 +} VkPipelineTessellationStateCreateInfo;
  8.1982 +
  8.1983 +typedef struct VkViewport {
  8.1984 +    float    x;
  8.1985 +    float    y;
  8.1986 +    float    width;
  8.1987 +    float    height;
  8.1988 +    float    minDepth;
  8.1989 +    float    maxDepth;
  8.1990 +} VkViewport;
  8.1991 +
  8.1992 +typedef struct VkOffset2D {
  8.1993 +    int32_t    x;
  8.1994 +    int32_t    y;
  8.1995 +} VkOffset2D;
  8.1996 +
  8.1997 +typedef struct VkExtent2D {
  8.1998 +    uint32_t    width;
  8.1999 +    uint32_t    height;
  8.2000 +} VkExtent2D;
  8.2001 +
  8.2002 +typedef struct VkRect2D {
  8.2003 +    VkOffset2D    offset;
  8.2004 +    VkExtent2D    extent;
  8.2005 +} VkRect2D;
  8.2006 +
  8.2007 +typedef struct VkPipelineViewportStateCreateInfo {
  8.2008 +    VkStructureType                       sType;
  8.2009 +    const void*                           pNext;
  8.2010 +    VkPipelineViewportStateCreateFlags    flags;
  8.2011 +    uint32_t                              viewportCount;
  8.2012 +    const VkViewport*                     pViewports;
  8.2013 +    uint32_t                              scissorCount;
  8.2014 +    const VkRect2D*                       pScissors;
  8.2015 +} VkPipelineViewportStateCreateInfo;
  8.2016 +
  8.2017 +typedef struct VkPipelineRasterizationStateCreateInfo {
  8.2018 +    VkStructureType                            sType;
  8.2019 +    const void*                                pNext;
  8.2020 +    VkPipelineRasterizationStateCreateFlags    flags;
  8.2021 +    VkBool32                                   depthClampEnable;
  8.2022 +    VkBool32                                   rasterizerDiscardEnable;
  8.2023 +    VkPolygonMode                              polygonMode;
  8.2024 +    VkCullModeFlags                            cullMode;
  8.2025 +    VkFrontFace                                frontFace;
  8.2026 +    VkBool32                                   depthBiasEnable;
  8.2027 +    float                                      depthBiasConstantFactor;
  8.2028 +    float                                      depthBiasClamp;
  8.2029 +    float                                      depthBiasSlopeFactor;
  8.2030 +    float                                      lineWidth;
  8.2031 +} VkPipelineRasterizationStateCreateInfo;
  8.2032 +
  8.2033 +typedef struct VkPipelineMultisampleStateCreateInfo {
  8.2034 +    VkStructureType                          sType;
  8.2035 +    const void*                              pNext;
  8.2036 +    VkPipelineMultisampleStateCreateFlags    flags;
  8.2037 +    VkSampleCountFlagBits                    rasterizationSamples;
  8.2038 +    VkBool32                                 sampleShadingEnable;
  8.2039 +    float                                    minSampleShading;
  8.2040 +    const VkSampleMask*                      pSampleMask;
  8.2041 +    VkBool32                                 alphaToCoverageEnable;
  8.2042 +    VkBool32                                 alphaToOneEnable;
  8.2043 +} VkPipelineMultisampleStateCreateInfo;
  8.2044 +
  8.2045 +typedef struct VkStencilOpState {
  8.2046 +    VkStencilOp    failOp;
  8.2047 +    VkStencilOp    passOp;
  8.2048 +    VkStencilOp    depthFailOp;
  8.2049 +    VkCompareOp    compareOp;
  8.2050 +    uint32_t       compareMask;
  8.2051 +    uint32_t       writeMask;
  8.2052 +    uint32_t       reference;
  8.2053 +} VkStencilOpState;
  8.2054 +
  8.2055 +typedef struct VkPipelineDepthStencilStateCreateInfo {
  8.2056 +    VkStructureType                           sType;
  8.2057 +    const void*                               pNext;
  8.2058 +    VkPipelineDepthStencilStateCreateFlags    flags;
  8.2059 +    VkBool32                                  depthTestEnable;
  8.2060 +    VkBool32                                  depthWriteEnable;
  8.2061 +    VkCompareOp                               depthCompareOp;
  8.2062 +    VkBool32                                  depthBoundsTestEnable;
  8.2063 +    VkBool32                                  stencilTestEnable;
  8.2064 +    VkStencilOpState                          front;
  8.2065 +    VkStencilOpState                          back;
  8.2066 +    float                                     minDepthBounds;
  8.2067 +    float                                     maxDepthBounds;
  8.2068 +} VkPipelineDepthStencilStateCreateInfo;
  8.2069 +
  8.2070 +typedef struct VkPipelineColorBlendAttachmentState {
  8.2071 +    VkBool32                 blendEnable;
  8.2072 +    VkBlendFactor            srcColorBlendFactor;
  8.2073 +    VkBlendFactor            dstColorBlendFactor;
  8.2074 +    VkBlendOp                colorBlendOp;
  8.2075 +    VkBlendFactor            srcAlphaBlendFactor;
  8.2076 +    VkBlendFactor            dstAlphaBlendFactor;
  8.2077 +    VkBlendOp                alphaBlendOp;
  8.2078 +    VkColorComponentFlags    colorWriteMask;
  8.2079 +} VkPipelineColorBlendAttachmentState;
  8.2080 +
  8.2081 +typedef struct VkPipelineColorBlendStateCreateInfo {
  8.2082 +    VkStructureType                               sType;
  8.2083 +    const void*                                   pNext;
  8.2084 +    VkPipelineColorBlendStateCreateFlags          flags;
  8.2085 +    VkBool32                                      logicOpEnable;
  8.2086 +    VkLogicOp                                     logicOp;
  8.2087 +    uint32_t                                      attachmentCount;
  8.2088 +    const VkPipelineColorBlendAttachmentState*    pAttachments;
  8.2089 +    float                                         blendConstants[4];
  8.2090 +} VkPipelineColorBlendStateCreateInfo;
  8.2091 +
  8.2092 +typedef struct VkPipelineDynamicStateCreateInfo {
  8.2093 +    VkStructureType                      sType;
  8.2094 +    const void*                          pNext;
  8.2095 +    VkPipelineDynamicStateCreateFlags    flags;
  8.2096 +    uint32_t                             dynamicStateCount;
  8.2097 +    const VkDynamicState*                pDynamicStates;
  8.2098 +} VkPipelineDynamicStateCreateInfo;
  8.2099 +
  8.2100 +typedef struct VkGraphicsPipelineCreateInfo {
  8.2101 +    VkStructureType                                  sType;
  8.2102 +    const void*                                      pNext;
  8.2103 +    VkPipelineCreateFlags                            flags;
  8.2104 +    uint32_t                                         stageCount;
  8.2105 +    const VkPipelineShaderStageCreateInfo*           pStages;
  8.2106 +    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
  8.2107 +    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
  8.2108 +    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
  8.2109 +    const VkPipelineViewportStateCreateInfo*         pViewportState;
  8.2110 +    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
  8.2111 +    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
  8.2112 +    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
  8.2113 +    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
  8.2114 +    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
  8.2115 +    VkPipelineLayout                                 layout;
  8.2116 +    VkRenderPass                                     renderPass;
  8.2117 +    uint32_t                                         subpass;
  8.2118 +    VkPipeline                                       basePipelineHandle;
  8.2119 +    int32_t                                          basePipelineIndex;
  8.2120 +} VkGraphicsPipelineCreateInfo;
  8.2121 +
  8.2122 +typedef struct VkComputePipelineCreateInfo {
  8.2123 +    VkStructureType                    sType;
  8.2124 +    const void*                        pNext;
  8.2125 +    VkPipelineCreateFlags              flags;
  8.2126 +    VkPipelineShaderStageCreateInfo    stage;
  8.2127 +    VkPipelineLayout                   layout;
  8.2128 +    VkPipeline                         basePipelineHandle;
  8.2129 +    int32_t                            basePipelineIndex;
  8.2130 +} VkComputePipelineCreateInfo;
  8.2131 +
  8.2132 +typedef struct VkPushConstantRange {
  8.2133 +    VkShaderStageFlags    stageFlags;
  8.2134 +    uint32_t              offset;
  8.2135 +    uint32_t              size;
  8.2136 +} VkPushConstantRange;
  8.2137 +
  8.2138 +typedef struct VkPipelineLayoutCreateInfo {
  8.2139 +    VkStructureType                 sType;
  8.2140 +    const void*                     pNext;
  8.2141 +    VkPipelineLayoutCreateFlags     flags;
  8.2142 +    uint32_t                        setLayoutCount;
  8.2143 +    const VkDescriptorSetLayout*    pSetLayouts;
  8.2144 +    uint32_t                        pushConstantRangeCount;
  8.2145 +    const VkPushConstantRange*      pPushConstantRanges;
  8.2146 +} VkPipelineLayoutCreateInfo;
  8.2147 +
  8.2148 +typedef struct VkSamplerCreateInfo {
  8.2149 +    VkStructureType         sType;
  8.2150 +    const void*             pNext;
  8.2151 +    VkSamplerCreateFlags    flags;
  8.2152 +    VkFilter                magFilter;
  8.2153 +    VkFilter                minFilter;
  8.2154 +    VkSamplerMipmapMode     mipmapMode;
  8.2155 +    VkSamplerAddressMode    addressModeU;
  8.2156 +    VkSamplerAddressMode    addressModeV;
  8.2157 +    VkSamplerAddressMode    addressModeW;
  8.2158 +    float                   mipLodBias;
  8.2159 +    VkBool32                anisotropyEnable;
  8.2160 +    float                   maxAnisotropy;
  8.2161 +    VkBool32                compareEnable;
  8.2162 +    VkCompareOp             compareOp;
  8.2163 +    float                   minLod;
  8.2164 +    float                   maxLod;
  8.2165 +    VkBorderColor           borderColor;
  8.2166 +    VkBool32                unnormalizedCoordinates;
  8.2167 +} VkSamplerCreateInfo;
  8.2168 +
  8.2169 +typedef struct VkDescriptorSetLayoutBinding {
  8.2170 +    uint32_t              binding;
  8.2171 +    VkDescriptorType      descriptorType;
  8.2172 +    uint32_t              descriptorCount;
  8.2173 +    VkShaderStageFlags    stageFlags;
  8.2174 +    const VkSampler*      pImmutableSamplers;
  8.2175 +} VkDescriptorSetLayoutBinding;
  8.2176 +
  8.2177 +typedef struct VkDescriptorSetLayoutCreateInfo {
  8.2178 +    VkStructureType                        sType;
  8.2179 +    const void*                            pNext;
  8.2180 +    VkDescriptorSetLayoutCreateFlags       flags;
  8.2181 +    uint32_t                               bindingCount;
  8.2182 +    const VkDescriptorSetLayoutBinding*    pBindings;
  8.2183 +} VkDescriptorSetLayoutCreateInfo;
  8.2184 +
  8.2185 +typedef struct VkDescriptorPoolSize {
  8.2186 +    VkDescriptorType    type;
  8.2187 +    uint32_t            descriptorCount;
  8.2188 +} VkDescriptorPoolSize;
  8.2189 +
  8.2190 +typedef struct VkDescriptorPoolCreateInfo {
  8.2191 +    VkStructureType                sType;
  8.2192 +    const void*                    pNext;
  8.2193 +    VkDescriptorPoolCreateFlags    flags;
  8.2194 +    uint32_t                       maxSets;
  8.2195 +    uint32_t                       poolSizeCount;
  8.2196 +    const VkDescriptorPoolSize*    pPoolSizes;
  8.2197 +} VkDescriptorPoolCreateInfo;
  8.2198 +
  8.2199 +typedef struct VkDescriptorSetAllocateInfo {
  8.2200 +    VkStructureType                 sType;
  8.2201 +    const void*                     pNext;
  8.2202 +    VkDescriptorPool                descriptorPool;
  8.2203 +    uint32_t                        descriptorSetCount;
  8.2204 +    const VkDescriptorSetLayout*    pSetLayouts;
  8.2205 +} VkDescriptorSetAllocateInfo;
  8.2206 +
  8.2207 +typedef struct VkDescriptorImageInfo {
  8.2208 +    VkSampler        sampler;
  8.2209 +    VkImageView      imageView;
  8.2210 +    VkImageLayout    imageLayout;
  8.2211 +} VkDescriptorImageInfo;
  8.2212 +
  8.2213 +typedef struct VkDescriptorBufferInfo {
  8.2214 +    VkBuffer        buffer;
  8.2215 +    VkDeviceSize    offset;
  8.2216 +    VkDeviceSize    range;
  8.2217 +} VkDescriptorBufferInfo;
  8.2218 +
  8.2219 +typedef struct VkWriteDescriptorSet {
  8.2220 +    VkStructureType                  sType;
  8.2221 +    const void*                      pNext;
  8.2222 +    VkDescriptorSet                  dstSet;
  8.2223 +    uint32_t                         dstBinding;
  8.2224 +    uint32_t                         dstArrayElement;
  8.2225 +    uint32_t                         descriptorCount;
  8.2226 +    VkDescriptorType                 descriptorType;
  8.2227 +    const VkDescriptorImageInfo*     pImageInfo;
  8.2228 +    const VkDescriptorBufferInfo*    pBufferInfo;
  8.2229 +    const VkBufferView*              pTexelBufferView;
  8.2230 +} VkWriteDescriptorSet;
  8.2231 +
  8.2232 +typedef struct VkCopyDescriptorSet {
  8.2233 +    VkStructureType    sType;
  8.2234 +    const void*        pNext;
  8.2235 +    VkDescriptorSet    srcSet;
  8.2236 +    uint32_t           srcBinding;
  8.2237 +    uint32_t           srcArrayElement;
  8.2238 +    VkDescriptorSet    dstSet;
  8.2239 +    uint32_t           dstBinding;
  8.2240 +    uint32_t           dstArrayElement;
  8.2241 +    uint32_t           descriptorCount;
  8.2242 +} VkCopyDescriptorSet;
  8.2243 +
  8.2244 +typedef struct VkFramebufferCreateInfo {
  8.2245 +    VkStructureType             sType;
  8.2246 +    const void*                 pNext;
  8.2247 +    VkFramebufferCreateFlags    flags;
  8.2248 +    VkRenderPass                renderPass;
  8.2249 +    uint32_t                    attachmentCount;
  8.2250 +    const VkImageView*          pAttachments;
  8.2251 +    uint32_t                    width;
  8.2252 +    uint32_t                    height;
  8.2253 +    uint32_t                    layers;
  8.2254 +} VkFramebufferCreateInfo;
  8.2255 +
  8.2256 +typedef struct VkAttachmentDescription {
  8.2257 +    VkAttachmentDescriptionFlags    flags;
  8.2258 +    VkFormat                        format;
  8.2259 +    VkSampleCountFlagBits           samples;
  8.2260 +    VkAttachmentLoadOp              loadOp;
  8.2261 +    VkAttachmentStoreOp             storeOp;
  8.2262 +    VkAttachmentLoadOp              stencilLoadOp;
  8.2263 +    VkAttachmentStoreOp             stencilStoreOp;
  8.2264 +    VkImageLayout                   initialLayout;
  8.2265 +    VkImageLayout                   finalLayout;
  8.2266 +} VkAttachmentDescription;
  8.2267 +
  8.2268 +typedef struct VkAttachmentReference {
  8.2269 +    uint32_t         attachment;
  8.2270 +    VkImageLayout    layout;
  8.2271 +} VkAttachmentReference;
  8.2272 +
  8.2273 +typedef struct VkSubpassDescription {
  8.2274 +    VkSubpassDescriptionFlags       flags;
  8.2275 +    VkPipelineBindPoint             pipelineBindPoint;
  8.2276 +    uint32_t                        inputAttachmentCount;
  8.2277 +    const VkAttachmentReference*    pInputAttachments;
  8.2278 +    uint32_t                        colorAttachmentCount;
  8.2279 +    const VkAttachmentReference*    pColorAttachments;
  8.2280 +    const VkAttachmentReference*    pResolveAttachments;
  8.2281 +    const VkAttachmentReference*    pDepthStencilAttachment;
  8.2282 +    uint32_t                        preserveAttachmentCount;
  8.2283 +    const uint32_t*                 pPreserveAttachments;
  8.2284 +} VkSubpassDescription;
  8.2285 +
  8.2286 +typedef struct VkSubpassDependency {
  8.2287 +    uint32_t                srcSubpass;
  8.2288 +    uint32_t                dstSubpass;
  8.2289 +    VkPipelineStageFlags    srcStageMask;
  8.2290 +    VkPipelineStageFlags    dstStageMask;
  8.2291 +    VkAccessFlags           srcAccessMask;
  8.2292 +    VkAccessFlags           dstAccessMask;
  8.2293 +    VkDependencyFlags       dependencyFlags;
  8.2294 +} VkSubpassDependency;
  8.2295 +
  8.2296 +typedef struct VkRenderPassCreateInfo {
  8.2297 +    VkStructureType                   sType;
  8.2298 +    const void*                       pNext;
  8.2299 +    VkRenderPassCreateFlags           flags;
  8.2300 +    uint32_t                          attachmentCount;
  8.2301 +    const VkAttachmentDescription*    pAttachments;
  8.2302 +    uint32_t                          subpassCount;
  8.2303 +    const VkSubpassDescription*       pSubpasses;
  8.2304 +    uint32_t                          dependencyCount;
  8.2305 +    const VkSubpassDependency*        pDependencies;
  8.2306 +} VkRenderPassCreateInfo;
  8.2307 +
  8.2308 +typedef struct VkCommandPoolCreateInfo {
  8.2309 +    VkStructureType             sType;
  8.2310 +    const void*                 pNext;
  8.2311 +    VkCommandPoolCreateFlags    flags;
  8.2312 +    uint32_t                    queueFamilyIndex;
  8.2313 +} VkCommandPoolCreateInfo;
  8.2314 +
  8.2315 +typedef struct VkCommandBufferAllocateInfo {
  8.2316 +    VkStructureType         sType;
  8.2317 +    const void*             pNext;
  8.2318 +    VkCommandPool           commandPool;
  8.2319 +    VkCommandBufferLevel    level;
  8.2320 +    uint32_t                commandBufferCount;
  8.2321 +} VkCommandBufferAllocateInfo;
  8.2322 +
  8.2323 +typedef struct VkCommandBufferInheritanceInfo {
  8.2324 +    VkStructureType                  sType;
  8.2325 +    const void*                      pNext;
  8.2326 +    VkRenderPass                     renderPass;
  8.2327 +    uint32_t                         subpass;
  8.2328 +    VkFramebuffer                    framebuffer;
  8.2329 +    VkBool32                         occlusionQueryEnable;
  8.2330 +    VkQueryControlFlags              queryFlags;
  8.2331 +    VkQueryPipelineStatisticFlags    pipelineStatistics;
  8.2332 +} VkCommandBufferInheritanceInfo;
  8.2333 +
  8.2334 +typedef struct VkCommandBufferBeginInfo {
  8.2335 +    VkStructureType                          sType;
  8.2336 +    const void*                              pNext;
  8.2337 +    VkCommandBufferUsageFlags                flags;
  8.2338 +    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
  8.2339 +} VkCommandBufferBeginInfo;
  8.2340 +
  8.2341 +typedef struct VkBufferCopy {
  8.2342 +    VkDeviceSize    srcOffset;
  8.2343 +    VkDeviceSize    dstOffset;
  8.2344 +    VkDeviceSize    size;
  8.2345 +} VkBufferCopy;
  8.2346 +
  8.2347 +typedef struct VkImageSubresourceLayers {
  8.2348 +    VkImageAspectFlags    aspectMask;
  8.2349 +    uint32_t              mipLevel;
  8.2350 +    uint32_t              baseArrayLayer;
  8.2351 +    uint32_t              layerCount;
  8.2352 +} VkImageSubresourceLayers;
  8.2353 +
  8.2354 +typedef struct VkImageCopy {
  8.2355 +    VkImageSubresourceLayers    srcSubresource;
  8.2356 +    VkOffset3D                  srcOffset;
  8.2357 +    VkImageSubresourceLayers    dstSubresource;
  8.2358 +    VkOffset3D                  dstOffset;
  8.2359 +    VkExtent3D                  extent;
  8.2360 +} VkImageCopy;
  8.2361 +
  8.2362 +typedef struct VkImageBlit {
  8.2363 +    VkImageSubresourceLayers    srcSubresource;
  8.2364 +    VkOffset3D                  srcOffsets[2];
  8.2365 +    VkImageSubresourceLayers    dstSubresource;
  8.2366 +    VkOffset3D                  dstOffsets[2];
  8.2367 +} VkImageBlit;
  8.2368 +
  8.2369 +typedef struct VkBufferImageCopy {
  8.2370 +    VkDeviceSize                bufferOffset;
  8.2371 +    uint32_t                    bufferRowLength;
  8.2372 +    uint32_t                    bufferImageHeight;
  8.2373 +    VkImageSubresourceLayers    imageSubresource;
  8.2374 +    VkOffset3D                  imageOffset;
  8.2375 +    VkExtent3D                  imageExtent;
  8.2376 +} VkBufferImageCopy;
  8.2377 +
  8.2378 +typedef union VkClearColorValue {
  8.2379 +    float       float32[4];
  8.2380 +    int32_t     int32[4];
  8.2381 +    uint32_t    uint32[4];
  8.2382 +} VkClearColorValue;
  8.2383 +
  8.2384 +typedef struct VkClearDepthStencilValue {
  8.2385 +    float       depth;
  8.2386 +    uint32_t    stencil;
  8.2387 +} VkClearDepthStencilValue;
  8.2388 +
  8.2389 +typedef union VkClearValue {
  8.2390 +    VkClearColorValue           color;
  8.2391 +    VkClearDepthStencilValue    depthStencil;
  8.2392 +} VkClearValue;
  8.2393 +
  8.2394 +typedef struct VkClearAttachment {
  8.2395 +    VkImageAspectFlags    aspectMask;
  8.2396 +    uint32_t              colorAttachment;
  8.2397 +    VkClearValue          clearValue;
  8.2398 +} VkClearAttachment;
  8.2399 +
  8.2400 +typedef struct VkClearRect {
  8.2401 +    VkRect2D    rect;
  8.2402 +    uint32_t    baseArrayLayer;
  8.2403 +    uint32_t    layerCount;
  8.2404 +} VkClearRect;
  8.2405 +
  8.2406 +typedef struct VkImageResolve {
  8.2407 +    VkImageSubresourceLayers    srcSubresource;
  8.2408 +    VkOffset3D                  srcOffset;
  8.2409 +    VkImageSubresourceLayers    dstSubresource;
  8.2410 +    VkOffset3D                  dstOffset;
  8.2411 +    VkExtent3D                  extent;
  8.2412 +} VkImageResolve;
  8.2413 +
  8.2414 +typedef struct VkMemoryBarrier {
  8.2415 +    VkStructureType    sType;
  8.2416 +    const void*        pNext;
  8.2417 +    VkAccessFlags      srcAccessMask;
  8.2418 +    VkAccessFlags      dstAccessMask;
  8.2419 +} VkMemoryBarrier;
  8.2420 +
  8.2421 +typedef struct VkBufferMemoryBarrier {
  8.2422 +    VkStructureType    sType;
  8.2423 +    const void*        pNext;
  8.2424 +    VkAccessFlags      srcAccessMask;
  8.2425 +    VkAccessFlags      dstAccessMask;
  8.2426 +    uint32_t           srcQueueFamilyIndex;
  8.2427 +    uint32_t           dstQueueFamilyIndex;
  8.2428 +    VkBuffer           buffer;
  8.2429 +    VkDeviceSize       offset;
  8.2430 +    VkDeviceSize       size;
  8.2431 +} VkBufferMemoryBarrier;
  8.2432 +
  8.2433 +typedef struct VkImageMemoryBarrier {
  8.2434 +    VkStructureType            sType;
  8.2435 +    const void*                pNext;
  8.2436 +    VkAccessFlags              srcAccessMask;
  8.2437 +    VkAccessFlags              dstAccessMask;
  8.2438 +    VkImageLayout              oldLayout;
  8.2439 +    VkImageLayout              newLayout;
  8.2440 +    uint32_t                   srcQueueFamilyIndex;
  8.2441 +    uint32_t                   dstQueueFamilyIndex;
  8.2442 +    VkImage                    image;
  8.2443 +    VkImageSubresourceRange    subresourceRange;
  8.2444 +} VkImageMemoryBarrier;
  8.2445 +
  8.2446 +typedef struct VkRenderPassBeginInfo {
  8.2447 +    VkStructureType        sType;
  8.2448 +    const void*            pNext;
  8.2449 +    VkRenderPass           renderPass;
  8.2450 +    VkFramebuffer          framebuffer;
  8.2451 +    VkRect2D               renderArea;
  8.2452 +    uint32_t               clearValueCount;
  8.2453 +    const VkClearValue*    pClearValues;
  8.2454 +} VkRenderPassBeginInfo;
  8.2455 +
  8.2456 +typedef struct VkDispatchIndirectCommand {
  8.2457 +    uint32_t    x;
  8.2458 +    uint32_t    y;
  8.2459 +    uint32_t    z;
  8.2460 +} VkDispatchIndirectCommand;
  8.2461 +
  8.2462 +typedef struct VkDrawIndexedIndirectCommand {
  8.2463 +    uint32_t    indexCount;
  8.2464 +    uint32_t    instanceCount;
  8.2465 +    uint32_t    firstIndex;
  8.2466 +    int32_t     vertexOffset;
  8.2467 +    uint32_t    firstInstance;
  8.2468 +} VkDrawIndexedIndirectCommand;
  8.2469 +
  8.2470 +typedef struct VkDrawIndirectCommand {
  8.2471 +    uint32_t    vertexCount;
  8.2472 +    uint32_t    instanceCount;
  8.2473 +    uint32_t    firstVertex;
  8.2474 +    uint32_t    firstInstance;
  8.2475 +} VkDrawIndirectCommand;
  8.2476 +
  8.2477 +
  8.2478 +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
  8.2479 +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
  8.2480 +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
  8.2481 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
  8.2482 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
  8.2483 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
  8.2484 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
  8.2485 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
  8.2486 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
  8.2487 +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
  8.2488 +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
  8.2489 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
  8.2490 +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
  8.2491 +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
  8.2492 +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
  8.2493 +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
  8.2494 +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
  8.2495 +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
  8.2496 +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
  8.2497 +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
  8.2498 +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
  8.2499 +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
  8.2500 +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
  8.2501 +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
  8.2502 +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
  8.2503 +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
  8.2504 +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
  8.2505 +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
  8.2506 +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
  8.2507 +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
  8.2508 +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
  8.2509 +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
  8.2510 +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
  8.2511 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
  8.2512 +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
  8.2513 +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  8.2514 +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
  8.2515 +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
  8.2516 +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
  8.2517 +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
  8.2518 +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
  8.2519 +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
  8.2520 +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
  8.2521 +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
  8.2522 +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
  8.2523 +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
  8.2524 +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
  8.2525 +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
  8.2526 +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
  8.2527 +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);
  8.2528 +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
  8.2529 +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
  8.2530 +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
  8.2531 +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
  8.2532 +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
  8.2533 +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
  8.2534 +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
  8.2535 +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
  8.2536 +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
  8.2537 +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
  8.2538 +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
  8.2539 +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
  8.2540 +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
  8.2541 +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
  8.2542 +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
  8.2543 +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
  8.2544 +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
  8.2545 +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
  8.2546 +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
  8.2547 +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
  8.2548 +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
  8.2549 +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
  8.2550 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
  8.2551 +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
  8.2552 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
  8.2553 +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
  8.2554 +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
  8.2555 +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
  8.2556 +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
  8.2557 +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
  8.2558 +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
  8.2559 +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
  8.2560 +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
  8.2561 +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
  8.2562 +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
  8.2563 +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
  8.2564 +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
  8.2565 +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
  8.2566 +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
  8.2567 +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
  8.2568 +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
  8.2569 +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
  8.2570 +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
  8.2571 +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
  8.2572 +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
  8.2573 +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
  8.2574 +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
  8.2575 +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
  8.2576 +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
  8.2577 +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
  8.2578 +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
  8.2579 +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
  8.2580 +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
  8.2581 +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);
  8.2582 +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
  8.2583 +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
  8.2584 +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
  8.2585 +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
  8.2586 +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
  8.2587 +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
  8.2588 +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
  8.2589 +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
  8.2590 +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
  8.2591 +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
  8.2592 +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
  8.2593 +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
  8.2594 +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
  8.2595 +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
  8.2596 +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
  8.2597 +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
  8.2598 +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
  8.2599 +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
  8.2600 +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
  8.2601 +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
  8.2602 +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
  8.2603 +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);
  8.2604 +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);
  8.2605 +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
  8.2606 +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
  8.2607 +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
  8.2608 +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
  8.2609 +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
  8.2610 +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
  8.2611 +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
  8.2612 +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
  8.2613 +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
  8.2614 +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
  8.2615 +
  8.2616 +#ifndef VK_NO_PROTOTYPES
  8.2617 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
  8.2618 +    const VkInstanceCreateInfo*                 pCreateInfo,
  8.2619 +    const VkAllocationCallbacks*                pAllocator,
  8.2620 +    VkInstance*                                 pInstance);
  8.2621 +
  8.2622 +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
  8.2623 +    VkInstance                                  instance,
  8.2624 +    const VkAllocationCallbacks*                pAllocator);
  8.2625 +
  8.2626 +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
  8.2627 +    VkInstance                                  instance,
  8.2628 +    uint32_t*                                   pPhysicalDeviceCount,
  8.2629 +    VkPhysicalDevice*                           pPhysicalDevices);
  8.2630 +
  8.2631 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
  8.2632 +    VkPhysicalDevice                            physicalDevice,
  8.2633 +    VkPhysicalDeviceFeatures*                   pFeatures);
  8.2634 +
  8.2635 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
  8.2636 +    VkPhysicalDevice                            physicalDevice,
  8.2637 +    VkFormat                                    format,
  8.2638 +    VkFormatProperties*                         pFormatProperties);
  8.2639 +
  8.2640 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
  8.2641 +    VkPhysicalDevice                            physicalDevice,
  8.2642 +    VkFormat                                    format,
  8.2643 +    VkImageType                                 type,
  8.2644 +    VkImageTiling                               tiling,
  8.2645 +    VkImageUsageFlags                           usage,
  8.2646 +    VkImageCreateFlags                          flags,
  8.2647 +    VkImageFormatProperties*                    pImageFormatProperties);
  8.2648 +
  8.2649 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
  8.2650 +    VkPhysicalDevice                            physicalDevice,
  8.2651 +    VkPhysicalDeviceProperties*                 pProperties);
  8.2652 +
  8.2653 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
  8.2654 +    VkPhysicalDevice                            physicalDevice,
  8.2655 +    uint32_t*                                   pQueueFamilyPropertyCount,
  8.2656 +    VkQueueFamilyProperties*                    pQueueFamilyProperties);
  8.2657 +
  8.2658 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
  8.2659 +    VkPhysicalDevice                            physicalDevice,
  8.2660 +    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
  8.2661 +
  8.2662 +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
  8.2663 +    VkInstance                                  instance,
  8.2664 +    const char*                                 pName);
  8.2665 +
  8.2666 +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
  8.2667 +    VkDevice                                    device,
  8.2668 +    const char*                                 pName);
  8.2669 +
  8.2670 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
  8.2671 +    VkPhysicalDevice                            physicalDevice,
  8.2672 +    const VkDeviceCreateInfo*                   pCreateInfo,
  8.2673 +    const VkAllocationCallbacks*                pAllocator,
  8.2674 +    VkDevice*                                   pDevice);
  8.2675 +
  8.2676 +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
  8.2677 +    VkDevice                                    device,
  8.2678 +    const VkAllocationCallbacks*                pAllocator);
  8.2679 +
  8.2680 +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
  8.2681 +    const char*                                 pLayerName,
  8.2682 +    uint32_t*                                   pPropertyCount,
  8.2683 +    VkExtensionProperties*                      pProperties);
  8.2684 +
  8.2685 +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
  8.2686 +    VkPhysicalDevice                            physicalDevice,
  8.2687 +    const char*                                 pLayerName,
  8.2688 +    uint32_t*                                   pPropertyCount,
  8.2689 +    VkExtensionProperties*                      pProperties);
  8.2690 +
  8.2691 +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
  8.2692 +    uint32_t*                                   pPropertyCount,
  8.2693 +    VkLayerProperties*                          pProperties);
  8.2694 +
  8.2695 +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
  8.2696 +    VkPhysicalDevice                            physicalDevice,
  8.2697 +    uint32_t*                                   pPropertyCount,
  8.2698 +    VkLayerProperties*                          pProperties);
  8.2699 +
  8.2700 +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
  8.2701 +    VkDevice                                    device,
  8.2702 +    uint32_t                                    queueFamilyIndex,
  8.2703 +    uint32_t                                    queueIndex,
  8.2704 +    VkQueue*                                    pQueue);
  8.2705 +
  8.2706 +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
  8.2707 +    VkQueue                                     queue,
  8.2708 +    uint32_t                                    submitCount,
  8.2709 +    const VkSubmitInfo*                         pSubmits,
  8.2710 +    VkFence                                     fence);
  8.2711 +
  8.2712 +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
  8.2713 +    VkQueue                                     queue);
  8.2714 +
  8.2715 +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
  8.2716 +    VkDevice                                    device);
  8.2717 +
  8.2718 +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
  8.2719 +    VkDevice                                    device,
  8.2720 +    const VkMemoryAllocateInfo*                 pAllocateInfo,
  8.2721 +    const VkAllocationCallbacks*                pAllocator,
  8.2722 +    VkDeviceMemory*                             pMemory);
  8.2723 +
  8.2724 +VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
  8.2725 +    VkDevice                                    device,
  8.2726 +    VkDeviceMemory                              memory,
  8.2727 +    const VkAllocationCallbacks*                pAllocator);
  8.2728 +
  8.2729 +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
  8.2730 +    VkDevice                                    device,
  8.2731 +    VkDeviceMemory                              memory,
  8.2732 +    VkDeviceSize                                offset,
  8.2733 +    VkDeviceSize                                size,
  8.2734 +    VkMemoryMapFlags                            flags,
  8.2735 +    void**                                      ppData);
  8.2736 +
  8.2737 +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
  8.2738 +    VkDevice                                    device,
  8.2739 +    VkDeviceMemory                              memory);
  8.2740 +
  8.2741 +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
  8.2742 +    VkDevice                                    device,
  8.2743 +    uint32_t                                    memoryRangeCount,
  8.2744 +    const VkMappedMemoryRange*                  pMemoryRanges);
  8.2745 +
  8.2746 +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
  8.2747 +    VkDevice                                    device,
  8.2748 +    uint32_t                                    memoryRangeCount,
  8.2749 +    const VkMappedMemoryRange*                  pMemoryRanges);
  8.2750 +
  8.2751 +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
  8.2752 +    VkDevice                                    device,
  8.2753 +    VkDeviceMemory                              memory,
  8.2754 +    VkDeviceSize*                               pCommittedMemoryInBytes);
  8.2755 +
  8.2756 +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
  8.2757 +    VkDevice                                    device,
  8.2758 +    VkBuffer                                    buffer,
  8.2759 +    VkDeviceMemory                              memory,
  8.2760 +    VkDeviceSize                                memoryOffset);
  8.2761 +
  8.2762 +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
  8.2763 +    VkDevice                                    device,
  8.2764 +    VkImage                                     image,
  8.2765 +    VkDeviceMemory                              memory,
  8.2766 +    VkDeviceSize                                memoryOffset);
  8.2767 +
  8.2768 +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
  8.2769 +    VkDevice                                    device,
  8.2770 +    VkBuffer                                    buffer,
  8.2771 +    VkMemoryRequirements*                       pMemoryRequirements);
  8.2772 +
  8.2773 +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
  8.2774 +    VkDevice                                    device,
  8.2775 +    VkImage                                     image,
  8.2776 +    VkMemoryRequirements*                       pMemoryRequirements);
  8.2777 +
  8.2778 +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
  8.2779 +    VkDevice                                    device,
  8.2780 +    VkImage                                     image,
  8.2781 +    uint32_t*                                   pSparseMemoryRequirementCount,
  8.2782 +    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
  8.2783 +
  8.2784 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
  8.2785 +    VkPhysicalDevice                            physicalDevice,
  8.2786 +    VkFormat                                    format,
  8.2787 +    VkImageType                                 type,
  8.2788 +    VkSampleCountFlagBits                       samples,
  8.2789 +    VkImageUsageFlags                           usage,
  8.2790 +    VkImageTiling                               tiling,
  8.2791 +    uint32_t*                                   pPropertyCount,
  8.2792 +    VkSparseImageFormatProperties*              pProperties);
  8.2793 +
  8.2794 +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
  8.2795 +    VkQueue                                     queue,
  8.2796 +    uint32_t                                    bindInfoCount,
  8.2797 +    const VkBindSparseInfo*                     pBindInfo,
  8.2798 +    VkFence                                     fence);
  8.2799 +
  8.2800 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
  8.2801 +    VkDevice                                    device,
  8.2802 +    const VkFenceCreateInfo*                    pCreateInfo,
  8.2803 +    const VkAllocationCallbacks*                pAllocator,
  8.2804 +    VkFence*                                    pFence);
  8.2805 +
  8.2806 +VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
  8.2807 +    VkDevice                                    device,
  8.2808 +    VkFence                                     fence,
  8.2809 +    const VkAllocationCallbacks*                pAllocator);
  8.2810 +
  8.2811 +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
  8.2812 +    VkDevice                                    device,
  8.2813 +    uint32_t                                    fenceCount,
  8.2814 +    const VkFence*                              pFences);
  8.2815 +
  8.2816 +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
  8.2817 +    VkDevice                                    device,
  8.2818 +    VkFence                                     fence);
  8.2819 +
  8.2820 +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
  8.2821 +    VkDevice                                    device,
  8.2822 +    uint32_t                                    fenceCount,
  8.2823 +    const VkFence*                              pFences,
  8.2824 +    VkBool32                                    waitAll,
  8.2825 +    uint64_t                                    timeout);
  8.2826 +
  8.2827 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
  8.2828 +    VkDevice                                    device,
  8.2829 +    const VkSemaphoreCreateInfo*                pCreateInfo,
  8.2830 +    const VkAllocationCallbacks*                pAllocator,
  8.2831 +    VkSemaphore*                                pSemaphore);
  8.2832 +
  8.2833 +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
  8.2834 +    VkDevice                                    device,
  8.2835 +    VkSemaphore                                 semaphore,
  8.2836 +    const VkAllocationCallbacks*                pAllocator);
  8.2837 +
  8.2838 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
  8.2839 +    VkDevice                                    device,
  8.2840 +    const VkEventCreateInfo*                    pCreateInfo,
  8.2841 +    const VkAllocationCallbacks*                pAllocator,
  8.2842 +    VkEvent*                                    pEvent);
  8.2843 +
  8.2844 +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
  8.2845 +    VkDevice                                    device,
  8.2846 +    VkEvent                                     event,
  8.2847 +    const VkAllocationCallbacks*                pAllocator);
  8.2848 +
  8.2849 +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
  8.2850 +    VkDevice                                    device,
  8.2851 +    VkEvent                                     event);
  8.2852 +
  8.2853 +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
  8.2854 +    VkDevice                                    device,
  8.2855 +    VkEvent                                     event);
  8.2856 +
  8.2857 +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
  8.2858 +    VkDevice                                    device,
  8.2859 +    VkEvent                                     event);
  8.2860 +
  8.2861 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
  8.2862 +    VkDevice                                    device,
  8.2863 +    const VkQueryPoolCreateInfo*                pCreateInfo,
  8.2864 +    const VkAllocationCallbacks*                pAllocator,
  8.2865 +    VkQueryPool*                                pQueryPool);
  8.2866 +
  8.2867 +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
  8.2868 +    VkDevice                                    device,
  8.2869 +    VkQueryPool                                 queryPool,
  8.2870 +    const VkAllocationCallbacks*                pAllocator);
  8.2871 +
  8.2872 +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
  8.2873 +    VkDevice                                    device,
  8.2874 +    VkQueryPool                                 queryPool,
  8.2875 +    uint32_t                                    firstQuery,
  8.2876 +    uint32_t                                    queryCount,
  8.2877 +    size_t                                      dataSize,
  8.2878 +    void*                                       pData,
  8.2879 +    VkDeviceSize                                stride,
  8.2880 +    VkQueryResultFlags                          flags);
  8.2881 +
  8.2882 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
  8.2883 +    VkDevice                                    device,
  8.2884 +    const VkBufferCreateInfo*                   pCreateInfo,
  8.2885 +    const VkAllocationCallbacks*                pAllocator,
  8.2886 +    VkBuffer*                                   pBuffer);
  8.2887 +
  8.2888 +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
  8.2889 +    VkDevice                                    device,
  8.2890 +    VkBuffer                                    buffer,
  8.2891 +    const VkAllocationCallbacks*                pAllocator);
  8.2892 +
  8.2893 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
  8.2894 +    VkDevice                                    device,
  8.2895 +    const VkBufferViewCreateInfo*               pCreateInfo,
  8.2896 +    const VkAllocationCallbacks*                pAllocator,
  8.2897 +    VkBufferView*                               pView);
  8.2898 +
  8.2899 +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
  8.2900 +    VkDevice                                    device,
  8.2901 +    VkBufferView                                bufferView,
  8.2902 +    const VkAllocationCallbacks*                pAllocator);
  8.2903 +
  8.2904 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
  8.2905 +    VkDevice                                    device,
  8.2906 +    const VkImageCreateInfo*                    pCreateInfo,
  8.2907 +    const VkAllocationCallbacks*                pAllocator,
  8.2908 +    VkImage*                                    pImage);
  8.2909 +
  8.2910 +VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
  8.2911 +    VkDevice                                    device,
  8.2912 +    VkImage                                     image,
  8.2913 +    const VkAllocationCallbacks*                pAllocator);
  8.2914 +
  8.2915 +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
  8.2916 +    VkDevice                                    device,
  8.2917 +    VkImage                                     image,
  8.2918 +    const VkImageSubresource*                   pSubresource,
  8.2919 +    VkSubresourceLayout*                        pLayout);
  8.2920 +
  8.2921 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
  8.2922 +    VkDevice                                    device,
  8.2923 +    const VkImageViewCreateInfo*                pCreateInfo,
  8.2924 +    const VkAllocationCallbacks*                pAllocator,
  8.2925 +    VkImageView*                                pView);
  8.2926 +
  8.2927 +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
  8.2928 +    VkDevice                                    device,
  8.2929 +    VkImageView                                 imageView,
  8.2930 +    const VkAllocationCallbacks*                pAllocator);
  8.2931 +
  8.2932 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
  8.2933 +    VkDevice                                    device,
  8.2934 +    const VkShaderModuleCreateInfo*             pCreateInfo,
  8.2935 +    const VkAllocationCallbacks*                pAllocator,
  8.2936 +    VkShaderModule*                             pShaderModule);
  8.2937 +
  8.2938 +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
  8.2939 +    VkDevice                                    device,
  8.2940 +    VkShaderModule                              shaderModule,
  8.2941 +    const VkAllocationCallbacks*                pAllocator);
  8.2942 +
  8.2943 +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
  8.2944 +    VkDevice                                    device,
  8.2945 +    const VkPipelineCacheCreateInfo*            pCreateInfo,
  8.2946 +    const VkAllocationCallbacks*                pAllocator,
  8.2947 +    VkPipelineCache*                            pPipelineCache);
  8.2948 +
  8.2949 +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
  8.2950 +    VkDevice                                    device,
  8.2951 +    VkPipelineCache                             pipelineCache,
  8.2952 +    const VkAllocationCallbacks*                pAllocator);
  8.2953 +
  8.2954 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
  8.2955 +    VkDevice                                    device,
  8.2956 +    VkPipelineCache                             pipelineCache,
  8.2957 +    size_t*                                     pDataSize,
  8.2958 +    void*                                       pData);
  8.2959 +
  8.2960 +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
  8.2961 +    VkDevice                                    device,
  8.2962 +    VkPipelineCache                             dstCache,
  8.2963 +    uint32_t                                    srcCacheCount,
  8.2964 +    const VkPipelineCache*                      pSrcCaches);
  8.2965 +
  8.2966 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
  8.2967 +    VkDevice                                    device,
  8.2968 +    VkPipelineCache                             pipelineCache,
  8.2969 +    uint32_t                                    createInfoCount,
  8.2970 +    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
  8.2971 +    const VkAllocationCallbacks*                pAllocator,
  8.2972 +    VkPipeline*                                 pPipelines);
  8.2973 +
  8.2974 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
  8.2975 +    VkDevice                                    device,
  8.2976 +    VkPipelineCache                             pipelineCache,
  8.2977 +    uint32_t                                    createInfoCount,
  8.2978 +    const VkComputePipelineCreateInfo*          pCreateInfos,
  8.2979 +    const VkAllocationCallbacks*                pAllocator,
  8.2980 +    VkPipeline*                                 pPipelines);
  8.2981 +
  8.2982 +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
  8.2983 +    VkDevice                                    device,
  8.2984 +    VkPipeline                                  pipeline,
  8.2985 +    const VkAllocationCallbacks*                pAllocator);
  8.2986 +
  8.2987 +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
  8.2988 +    VkDevice                                    device,
  8.2989 +    const VkPipelineLayoutCreateInfo*           pCreateInfo,
  8.2990 +    const VkAllocationCallbacks*                pAllocator,
  8.2991 +    VkPipelineLayout*                           pPipelineLayout);
  8.2992 +
  8.2993 +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
  8.2994 +    VkDevice                                    device,
  8.2995 +    VkPipelineLayout                            pipelineLayout,
  8.2996 +    const VkAllocationCallbacks*                pAllocator);
  8.2997 +
  8.2998 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
  8.2999 +    VkDevice                                    device,
  8.3000 +    const VkSamplerCreateInfo*                  pCreateInfo,
  8.3001 +    const VkAllocationCallbacks*                pAllocator,
  8.3002 +    VkSampler*                                  pSampler);
  8.3003 +
  8.3004 +VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
  8.3005 +    VkDevice                                    device,
  8.3006 +    VkSampler                                   sampler,
  8.3007 +    const VkAllocationCallbacks*                pAllocator);
  8.3008 +
  8.3009 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
  8.3010 +    VkDevice                                    device,
  8.3011 +    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
  8.3012 +    const VkAllocationCallbacks*                pAllocator,
  8.3013 +    VkDescriptorSetLayout*                      pSetLayout);
  8.3014 +
  8.3015 +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
  8.3016 +    VkDevice                                    device,
  8.3017 +    VkDescriptorSetLayout                       descriptorSetLayout,
  8.3018 +    const VkAllocationCallbacks*                pAllocator);
  8.3019 +
  8.3020 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
  8.3021 +    VkDevice                                    device,
  8.3022 +    const VkDescriptorPoolCreateInfo*           pCreateInfo,
  8.3023 +    const VkAllocationCallbacks*                pAllocator,
  8.3024 +    VkDescriptorPool*                           pDescriptorPool);
  8.3025 +
  8.3026 +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
  8.3027 +    VkDevice                                    device,
  8.3028 +    VkDescriptorPool                            descriptorPool,
  8.3029 +    const VkAllocationCallbacks*                pAllocator);
  8.3030 +
  8.3031 +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
  8.3032 +    VkDevice                                    device,
  8.3033 +    VkDescriptorPool                            descriptorPool,
  8.3034 +    VkDescriptorPoolResetFlags                  flags);
  8.3035 +
  8.3036 +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
  8.3037 +    VkDevice                                    device,
  8.3038 +    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
  8.3039 +    VkDescriptorSet*                            pDescriptorSets);
  8.3040 +
  8.3041 +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
  8.3042 +    VkDevice                                    device,
  8.3043 +    VkDescriptorPool                            descriptorPool,
  8.3044 +    uint32_t                                    descriptorSetCount,
  8.3045 +    const VkDescriptorSet*                      pDescriptorSets);
  8.3046 +
  8.3047 +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
  8.3048 +    VkDevice                                    device,
  8.3049 +    uint32_t                                    descriptorWriteCount,
  8.3050 +    const VkWriteDescriptorSet*                 pDescriptorWrites,
  8.3051 +    uint32_t                                    descriptorCopyCount,
  8.3052 +    const VkCopyDescriptorSet*                  pDescriptorCopies);
  8.3053 +
  8.3054 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
  8.3055 +    VkDevice                                    device,
  8.3056 +    const VkFramebufferCreateInfo*              pCreateInfo,
  8.3057 +    const VkAllocationCallbacks*                pAllocator,
  8.3058 +    VkFramebuffer*                              pFramebuffer);
  8.3059 +
  8.3060 +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
  8.3061 +    VkDevice                                    device,
  8.3062 +    VkFramebuffer                               framebuffer,
  8.3063 +    const VkAllocationCallbacks*                pAllocator);
  8.3064 +
  8.3065 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
  8.3066 +    VkDevice                                    device,
  8.3067 +    const VkRenderPassCreateInfo*               pCreateInfo,
  8.3068 +    const VkAllocationCallbacks*                pAllocator,
  8.3069 +    VkRenderPass*                               pRenderPass);
  8.3070 +
  8.3071 +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
  8.3072 +    VkDevice                                    device,
  8.3073 +    VkRenderPass                                renderPass,
  8.3074 +    const VkAllocationCallbacks*                pAllocator);
  8.3075 +
  8.3076 +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
  8.3077 +    VkDevice                                    device,
  8.3078 +    VkRenderPass                                renderPass,
  8.3079 +    VkExtent2D*                                 pGranularity);
  8.3080 +
  8.3081 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
  8.3082 +    VkDevice                                    device,
  8.3083 +    const VkCommandPoolCreateInfo*              pCreateInfo,
  8.3084 +    const VkAllocationCallbacks*                pAllocator,
  8.3085 +    VkCommandPool*                              pCommandPool);
  8.3086 +
  8.3087 +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
  8.3088 +    VkDevice                                    device,
  8.3089 +    VkCommandPool                               commandPool,
  8.3090 +    const VkAllocationCallbacks*                pAllocator);
  8.3091 +
  8.3092 +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
  8.3093 +    VkDevice                                    device,
  8.3094 +    VkCommandPool                               commandPool,
  8.3095 +    VkCommandPoolResetFlags                     flags);
  8.3096 +
  8.3097 +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
  8.3098 +    VkDevice                                    device,
  8.3099 +    const VkCommandBufferAllocateInfo*          pAllocateInfo,
  8.3100 +    VkCommandBuffer*                            pCommandBuffers);
  8.3101 +
  8.3102 +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
  8.3103 +    VkDevice                                    device,
  8.3104 +    VkCommandPool                               commandPool,
  8.3105 +    uint32_t                                    commandBufferCount,
  8.3106 +    const VkCommandBuffer*                      pCommandBuffers);
  8.3107 +
  8.3108 +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
  8.3109 +    VkCommandBuffer                             commandBuffer,
  8.3110 +    const VkCommandBufferBeginInfo*             pBeginInfo);
  8.3111 +
  8.3112 +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
  8.3113 +    VkCommandBuffer                             commandBuffer);
  8.3114 +
  8.3115 +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
  8.3116 +    VkCommandBuffer                             commandBuffer,
  8.3117 +    VkCommandBufferResetFlags                   flags);
  8.3118 +
  8.3119 +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
  8.3120 +    VkCommandBuffer                             commandBuffer,
  8.3121 +    VkPipelineBindPoint                         pipelineBindPoint,
  8.3122 +    VkPipeline                                  pipeline);
  8.3123 +
  8.3124 +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
  8.3125 +    VkCommandBuffer                             commandBuffer,
  8.3126 +    uint32_t                                    firstViewport,
  8.3127 +    uint32_t                                    viewportCount,
  8.3128 +    const VkViewport*                           pViewports);
  8.3129 +
  8.3130 +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
  8.3131 +    VkCommandBuffer                             commandBuffer,
  8.3132 +    uint32_t                                    firstScissor,
  8.3133 +    uint32_t                                    scissorCount,
  8.3134 +    const VkRect2D*                             pScissors);
  8.3135 +
  8.3136 +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
  8.3137 +    VkCommandBuffer                             commandBuffer,
  8.3138 +    float                                       lineWidth);
  8.3139 +
  8.3140 +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
  8.3141 +    VkCommandBuffer                             commandBuffer,
  8.3142 +    float                                       depthBiasConstantFactor,
  8.3143 +    float                                       depthBiasClamp,
  8.3144 +    float                                       depthBiasSlopeFactor);
  8.3145 +
  8.3146 +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
  8.3147 +    VkCommandBuffer                             commandBuffer,
  8.3148 +    const float                                 blendConstants[4]);
  8.3149 +
  8.3150 +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
  8.3151 +    VkCommandBuffer                             commandBuffer,
  8.3152 +    float                                       minDepthBounds,
  8.3153 +    float                                       maxDepthBounds);
  8.3154 +
  8.3155 +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
  8.3156 +    VkCommandBuffer                             commandBuffer,
  8.3157 +    VkStencilFaceFlags                          faceMask,
  8.3158 +    uint32_t                                    compareMask);
  8.3159 +
  8.3160 +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
  8.3161 +    VkCommandBuffer                             commandBuffer,
  8.3162 +    VkStencilFaceFlags                          faceMask,
  8.3163 +    uint32_t                                    writeMask);
  8.3164 +
  8.3165 +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
  8.3166 +    VkCommandBuffer                             commandBuffer,
  8.3167 +    VkStencilFaceFlags                          faceMask,
  8.3168 +    uint32_t                                    reference);
  8.3169 +
  8.3170 +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
  8.3171 +    VkCommandBuffer                             commandBuffer,
  8.3172 +    VkPipelineBindPoint                         pipelineBindPoint,
  8.3173 +    VkPipelineLayout                            layout,
  8.3174 +    uint32_t                                    firstSet,
  8.3175 +    uint32_t                                    descriptorSetCount,
  8.3176 +    const VkDescriptorSet*                      pDescriptorSets,
  8.3177 +    uint32_t                                    dynamicOffsetCount,
  8.3178 +    const uint32_t*                             pDynamicOffsets);
  8.3179 +
  8.3180 +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
  8.3181 +    VkCommandBuffer                             commandBuffer,
  8.3182 +    VkBuffer                                    buffer,
  8.3183 +    VkDeviceSize                                offset,
  8.3184 +    VkIndexType                                 indexType);
  8.3185 +
  8.3186 +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
  8.3187 +    VkCommandBuffer                             commandBuffer,
  8.3188 +    uint32_t                                    firstBinding,
  8.3189 +    uint32_t                                    bindingCount,
  8.3190 +    const VkBuffer*                             pBuffers,
  8.3191 +    const VkDeviceSize*                         pOffsets);
  8.3192 +
  8.3193 +VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
  8.3194 +    VkCommandBuffer                             commandBuffer,
  8.3195 +    uint32_t                                    vertexCount,
  8.3196 +    uint32_t                                    instanceCount,
  8.3197 +    uint32_t                                    firstVertex,
  8.3198 +    uint32_t                                    firstInstance);
  8.3199 +
  8.3200 +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
  8.3201 +    VkCommandBuffer                             commandBuffer,
  8.3202 +    uint32_t                                    indexCount,
  8.3203 +    uint32_t                                    instanceCount,
  8.3204 +    uint32_t                                    firstIndex,
  8.3205 +    int32_t                                     vertexOffset,
  8.3206 +    uint32_t                                    firstInstance);
  8.3207 +
  8.3208 +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
  8.3209 +    VkCommandBuffer                             commandBuffer,
  8.3210 +    VkBuffer                                    buffer,
  8.3211 +    VkDeviceSize                                offset,
  8.3212 +    uint32_t                                    drawCount,
  8.3213 +    uint32_t                                    stride);
  8.3214 +
  8.3215 +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
  8.3216 +    VkCommandBuffer                             commandBuffer,
  8.3217 +    VkBuffer                                    buffer,
  8.3218 +    VkDeviceSize                                offset,
  8.3219 +    uint32_t                                    drawCount,
  8.3220 +    uint32_t                                    stride);
  8.3221 +
  8.3222 +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
  8.3223 +    VkCommandBuffer                             commandBuffer,
  8.3224 +    uint32_t                                    groupCountX,
  8.3225 +    uint32_t                                    groupCountY,
  8.3226 +    uint32_t                                    groupCountZ);
  8.3227 +
  8.3228 +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
  8.3229 +    VkCommandBuffer                             commandBuffer,
  8.3230 +    VkBuffer                                    buffer,
  8.3231 +    VkDeviceSize                                offset);
  8.3232 +
  8.3233 +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
  8.3234 +    VkCommandBuffer                             commandBuffer,
  8.3235 +    VkBuffer                                    srcBuffer,
  8.3236 +    VkBuffer                                    dstBuffer,
  8.3237 +    uint32_t                                    regionCount,
  8.3238 +    const VkBufferCopy*                         pRegions);
  8.3239 +
  8.3240 +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
  8.3241 +    VkCommandBuffer                             commandBuffer,
  8.3242 +    VkImage                                     srcImage,
  8.3243 +    VkImageLayout                               srcImageLayout,
  8.3244 +    VkImage                                     dstImage,
  8.3245 +    VkImageLayout                               dstImageLayout,
  8.3246 +    uint32_t                                    regionCount,
  8.3247 +    const VkImageCopy*                          pRegions);
  8.3248 +
  8.3249 +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
  8.3250 +    VkCommandBuffer                             commandBuffer,
  8.3251 +    VkImage                                     srcImage,
  8.3252 +    VkImageLayout                               srcImageLayout,
  8.3253 +    VkImage                                     dstImage,
  8.3254 +    VkImageLayout                               dstImageLayout,
  8.3255 +    uint32_t                                    regionCount,
  8.3256 +    const VkImageBlit*                          pRegions,
  8.3257 +    VkFilter                                    filter);
  8.3258 +
  8.3259 +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
  8.3260 +    VkCommandBuffer                             commandBuffer,
  8.3261 +    VkBuffer                                    srcBuffer,
  8.3262 +    VkImage                                     dstImage,
  8.3263 +    VkImageLayout                               dstImageLayout,
  8.3264 +    uint32_t                                    regionCount,
  8.3265 +    const VkBufferImageCopy*                    pRegions);
  8.3266 +
  8.3267 +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
  8.3268 +    VkCommandBuffer                             commandBuffer,
  8.3269 +    VkImage                                     srcImage,
  8.3270 +    VkImageLayout                               srcImageLayout,
  8.3271 +    VkBuffer                                    dstBuffer,
  8.3272 +    uint32_t                                    regionCount,
  8.3273 +    const VkBufferImageCopy*                    pRegions);
  8.3274 +
  8.3275 +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
  8.3276 +    VkCommandBuffer                             commandBuffer,
  8.3277 +    VkBuffer                                    dstBuffer,
  8.3278 +    VkDeviceSize                                dstOffset,
  8.3279 +    VkDeviceSize                                dataSize,
  8.3280 +    const void*                                 pData);
  8.3281 +
  8.3282 +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
  8.3283 +    VkCommandBuffer                             commandBuffer,
  8.3284 +    VkBuffer                                    dstBuffer,
  8.3285 +    VkDeviceSize                                dstOffset,
  8.3286 +    VkDeviceSize                                size,
  8.3287 +    uint32_t                                    data);
  8.3288 +
  8.3289 +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
  8.3290 +    VkCommandBuffer                             commandBuffer,
  8.3291 +    VkImage                                     image,
  8.3292 +    VkImageLayout                               imageLayout,
  8.3293 +    const VkClearColorValue*                    pColor,
  8.3294 +    uint32_t                                    rangeCount,
  8.3295 +    const VkImageSubresourceRange*              pRanges);
  8.3296 +
  8.3297 +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
  8.3298 +    VkCommandBuffer                             commandBuffer,
  8.3299 +    VkImage                                     image,
  8.3300 +    VkImageLayout                               imageLayout,
  8.3301 +    const VkClearDepthStencilValue*             pDepthStencil,
  8.3302 +    uint32_t                                    rangeCount,
  8.3303 +    const VkImageSubresourceRange*              pRanges);
  8.3304 +
  8.3305 +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
  8.3306 +    VkCommandBuffer                             commandBuffer,
  8.3307 +    uint32_t                                    attachmentCount,
  8.3308 +    const VkClearAttachment*                    pAttachments,
  8.3309 +    uint32_t                                    rectCount,
  8.3310 +    const VkClearRect*                          pRects);
  8.3311 +
  8.3312 +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
  8.3313 +    VkCommandBuffer                             commandBuffer,
  8.3314 +    VkImage                                     srcImage,
  8.3315 +    VkImageLayout                               srcImageLayout,
  8.3316 +    VkImage                                     dstImage,
  8.3317 +    VkImageLayout                               dstImageLayout,
  8.3318 +    uint32_t                                    regionCount,
  8.3319 +    const VkImageResolve*                       pRegions);
  8.3320 +
  8.3321 +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
  8.3322 +    VkCommandBuffer                             commandBuffer,
  8.3323 +    VkEvent                                     event,
  8.3324 +    VkPipelineStageFlags                        stageMask);
  8.3325 +
  8.3326 +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
  8.3327 +    VkCommandBuffer                             commandBuffer,
  8.3328 +    VkEvent                                     event,
  8.3329 +    VkPipelineStageFlags                        stageMask);
  8.3330 +
  8.3331 +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
  8.3332 +    VkCommandBuffer                             commandBuffer,
  8.3333 +    uint32_t                                    eventCount,
  8.3334 +    const VkEvent*                              pEvents,
  8.3335 +    VkPipelineStageFlags                        srcStageMask,
  8.3336 +    VkPipelineStageFlags                        dstStageMask,
  8.3337 +    uint32_t                                    memoryBarrierCount,
  8.3338 +    const VkMemoryBarrier*                      pMemoryBarriers,
  8.3339 +    uint32_t                                    bufferMemoryBarrierCount,
  8.3340 +    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
  8.3341 +    uint32_t                                    imageMemoryBarrierCount,
  8.3342 +    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
  8.3343 +
  8.3344 +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
  8.3345 +    VkCommandBuffer                             commandBuffer,
  8.3346 +    VkPipelineStageFlags                        srcStageMask,
  8.3347 +    VkPipelineStageFlags                        dstStageMask,
  8.3348 +    VkDependencyFlags                           dependencyFlags,
  8.3349 +    uint32_t                                    memoryBarrierCount,
  8.3350 +    const VkMemoryBarrier*                      pMemoryBarriers,
  8.3351 +    uint32_t                                    bufferMemoryBarrierCount,
  8.3352 +    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
  8.3353 +    uint32_t                                    imageMemoryBarrierCount,
  8.3354 +    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
  8.3355 +
  8.3356 +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
  8.3357 +    VkCommandBuffer                             commandBuffer,
  8.3358 +    VkQueryPool                                 queryPool,
  8.3359 +    uint32_t                                    query,
  8.3360 +    VkQueryControlFlags                         flags);
  8.3361 +
  8.3362 +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
  8.3363 +    VkCommandBuffer                             commandBuffer,
  8.3364 +    VkQueryPool                                 queryPool,
  8.3365 +    uint32_t                                    query);
  8.3366 +
  8.3367 +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
  8.3368 +    VkCommandBuffer                             commandBuffer,
  8.3369 +    VkQueryPool                                 queryPool,
  8.3370 +    uint32_t                                    firstQuery,
  8.3371 +    uint32_t                                    queryCount);
  8.3372 +
  8.3373 +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
  8.3374 +    VkCommandBuffer                             commandBuffer,
  8.3375 +    VkPipelineStageFlagBits                     pipelineStage,
  8.3376 +    VkQueryPool                                 queryPool,
  8.3377 +    uint32_t                                    query);
  8.3378 +
  8.3379 +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
  8.3380 +    VkCommandBuffer                             commandBuffer,
  8.3381 +    VkQueryPool                                 queryPool,
  8.3382 +    uint32_t                                    firstQuery,
  8.3383 +    uint32_t                                    queryCount,
  8.3384 +    VkBuffer                                    dstBuffer,
  8.3385 +    VkDeviceSize                                dstOffset,
  8.3386 +    VkDeviceSize                                stride,
  8.3387 +    VkQueryResultFlags                          flags);
  8.3388 +
  8.3389 +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
  8.3390 +    VkCommandBuffer                             commandBuffer,
  8.3391 +    VkPipelineLayout                            layout,
  8.3392 +    VkShaderStageFlags                          stageFlags,
  8.3393 +    uint32_t                                    offset,
  8.3394 +    uint32_t                                    size,
  8.3395 +    const void*                                 pValues);
  8.3396 +
  8.3397 +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
  8.3398 +    VkCommandBuffer                             commandBuffer,
  8.3399 +    const VkRenderPassBeginInfo*                pRenderPassBegin,
  8.3400 +    VkSubpassContents                           contents);
  8.3401 +
  8.3402 +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
  8.3403 +    VkCommandBuffer                             commandBuffer,
  8.3404 +    VkSubpassContents                           contents);
  8.3405 +
  8.3406 +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
  8.3407 +    VkCommandBuffer                             commandBuffer);
  8.3408 +
  8.3409 +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
  8.3410 +    VkCommandBuffer                             commandBuffer,
  8.3411 +    uint32_t                                    commandBufferCount,
  8.3412 +    const VkCommandBuffer*                      pCommandBuffers);
  8.3413 +#endif
  8.3414 +
  8.3415 +#define VK_KHR_surface 1
  8.3416 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
  8.3417 +
  8.3418 +#define VK_KHR_SURFACE_SPEC_VERSION       25
  8.3419 +#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
  8.3420 +#define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
  8.3421 +
  8.3422 +
  8.3423 +typedef enum VkColorSpaceKHR {
  8.3424 +    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
  8.3425 +    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
  8.3426 +    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
  8.3427 +    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
  8.3428 +    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
  8.3429 +    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
  8.3430 +    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
  8.3431 +    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
  8.3432 +    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
  8.3433 +    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
  8.3434 +    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
  8.3435 +    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
  8.3436 +    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
  8.3437 +    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
  8.3438 +    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
  8.3439 +    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
  8.3440 +    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
  8.3441 +    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
  8.3442 +    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
  8.3443 +} VkColorSpaceKHR;
  8.3444 +
  8.3445 +typedef enum VkPresentModeKHR {
  8.3446 +    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
  8.3447 +    VK_PRESENT_MODE_MAILBOX_KHR = 1,
  8.3448 +    VK_PRESENT_MODE_FIFO_KHR = 2,
  8.3449 +    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
  8.3450 +    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
  8.3451 +    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
  8.3452 +    VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
  8.3453 +    VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
  8.3454 +    VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
  8.3455 +    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
  8.3456 +} VkPresentModeKHR;
  8.3457 +
  8.3458 +
  8.3459 +typedef enum VkSurfaceTransformFlagBitsKHR {
  8.3460 +    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
  8.3461 +    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
  8.3462 +    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
  8.3463 +    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
  8.3464 +    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
  8.3465 +    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
  8.3466 +    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
  8.3467 +    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
  8.3468 +    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
  8.3469 +    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.3470 +} VkSurfaceTransformFlagBitsKHR;
  8.3471 +typedef VkFlags VkSurfaceTransformFlagsKHR;
  8.3472 +
  8.3473 +typedef enum VkCompositeAlphaFlagBitsKHR {
  8.3474 +    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
  8.3475 +    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
  8.3476 +    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
  8.3477 +    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
  8.3478 +    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.3479 +} VkCompositeAlphaFlagBitsKHR;
  8.3480 +typedef VkFlags VkCompositeAlphaFlagsKHR;
  8.3481 +
  8.3482 +typedef struct VkSurfaceCapabilitiesKHR {
  8.3483 +    uint32_t                         minImageCount;
  8.3484 +    uint32_t                         maxImageCount;
  8.3485 +    VkExtent2D                       currentExtent;
  8.3486 +    VkExtent2D                       minImageExtent;
  8.3487 +    VkExtent2D                       maxImageExtent;
  8.3488 +    uint32_t                         maxImageArrayLayers;
  8.3489 +    VkSurfaceTransformFlagsKHR       supportedTransforms;
  8.3490 +    VkSurfaceTransformFlagBitsKHR    currentTransform;
  8.3491 +    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
  8.3492 +    VkImageUsageFlags                supportedUsageFlags;
  8.3493 +} VkSurfaceCapabilitiesKHR;
  8.3494 +
  8.3495 +typedef struct VkSurfaceFormatKHR {
  8.3496 +    VkFormat           format;
  8.3497 +    VkColorSpaceKHR    colorSpace;
  8.3498 +} VkSurfaceFormatKHR;
  8.3499 +
  8.3500 +
  8.3501 +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
  8.3502 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
  8.3503 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
  8.3504 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
  8.3505 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
  8.3506 +
  8.3507 +#ifndef VK_NO_PROTOTYPES
  8.3508 +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
  8.3509 +    VkInstance                                  instance,
  8.3510 +    VkSurfaceKHR                                surface,
  8.3511 +    const VkAllocationCallbacks*                pAllocator);
  8.3512 +
  8.3513 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
  8.3514 +    VkPhysicalDevice                            physicalDevice,
  8.3515 +    uint32_t                                    queueFamilyIndex,
  8.3516 +    VkSurfaceKHR                                surface,
  8.3517 +    VkBool32*                                   pSupported);
  8.3518 +
  8.3519 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
  8.3520 +    VkPhysicalDevice                            physicalDevice,
  8.3521 +    VkSurfaceKHR                                surface,
  8.3522 +    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
  8.3523 +
  8.3524 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
  8.3525 +    VkPhysicalDevice                            physicalDevice,
  8.3526 +    VkSurfaceKHR                                surface,
  8.3527 +    uint32_t*                                   pSurfaceFormatCount,
  8.3528 +    VkSurfaceFormatKHR*                         pSurfaceFormats);
  8.3529 +
  8.3530 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
  8.3531 +    VkPhysicalDevice                            physicalDevice,
  8.3532 +    VkSurfaceKHR                                surface,
  8.3533 +    uint32_t*                                   pPresentModeCount,
  8.3534 +    VkPresentModeKHR*                           pPresentModes);
  8.3535 +#endif
  8.3536 +
  8.3537 +#define VK_KHR_swapchain 1
  8.3538 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
  8.3539 +
  8.3540 +#define VK_KHR_SWAPCHAIN_SPEC_VERSION     68
  8.3541 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
  8.3542 +
  8.3543 +
  8.3544 +typedef enum VkSwapchainCreateFlagBitsKHR {
  8.3545 +    VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
  8.3546 +    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.3547 +} VkSwapchainCreateFlagBitsKHR;
  8.3548 +typedef VkFlags VkSwapchainCreateFlagsKHR;
  8.3549 +
  8.3550 +typedef struct VkSwapchainCreateInfoKHR {
  8.3551 +    VkStructureType                  sType;
  8.3552 +    const void*                      pNext;
  8.3553 +    VkSwapchainCreateFlagsKHR        flags;
  8.3554 +    VkSurfaceKHR                     surface;
  8.3555 +    uint32_t                         minImageCount;
  8.3556 +    VkFormat                         imageFormat;
  8.3557 +    VkColorSpaceKHR                  imageColorSpace;
  8.3558 +    VkExtent2D                       imageExtent;
  8.3559 +    uint32_t                         imageArrayLayers;
  8.3560 +    VkImageUsageFlags                imageUsage;
  8.3561 +    VkSharingMode                    imageSharingMode;
  8.3562 +    uint32_t                         queueFamilyIndexCount;
  8.3563 +    const uint32_t*                  pQueueFamilyIndices;
  8.3564 +    VkSurfaceTransformFlagBitsKHR    preTransform;
  8.3565 +    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
  8.3566 +    VkPresentModeKHR                 presentMode;
  8.3567 +    VkBool32                         clipped;
  8.3568 +    VkSwapchainKHR                   oldSwapchain;
  8.3569 +} VkSwapchainCreateInfoKHR;
  8.3570 +
  8.3571 +typedef struct VkPresentInfoKHR {
  8.3572 +    VkStructureType          sType;
  8.3573 +    const void*              pNext;
  8.3574 +    uint32_t                 waitSemaphoreCount;
  8.3575 +    const VkSemaphore*       pWaitSemaphores;
  8.3576 +    uint32_t                 swapchainCount;
  8.3577 +    const VkSwapchainKHR*    pSwapchains;
  8.3578 +    const uint32_t*          pImageIndices;
  8.3579 +    VkResult*                pResults;
  8.3580 +} VkPresentInfoKHR;
  8.3581 +
  8.3582 +
  8.3583 +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
  8.3584 +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
  8.3585 +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
  8.3586 +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
  8.3587 +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
  8.3588 +
  8.3589 +#ifndef VK_NO_PROTOTYPES
  8.3590 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
  8.3591 +    VkDevice                                    device,
  8.3592 +    const VkSwapchainCreateInfoKHR*             pCreateInfo,
  8.3593 +    const VkAllocationCallbacks*                pAllocator,
  8.3594 +    VkSwapchainKHR*                             pSwapchain);
  8.3595 +
  8.3596 +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
  8.3597 +    VkDevice                                    device,
  8.3598 +    VkSwapchainKHR                              swapchain,
  8.3599 +    const VkAllocationCallbacks*                pAllocator);
  8.3600 +
  8.3601 +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
  8.3602 +    VkDevice                                    device,
  8.3603 +    VkSwapchainKHR                              swapchain,
  8.3604 +    uint32_t*                                   pSwapchainImageCount,
  8.3605 +    VkImage*                                    pSwapchainImages);
  8.3606 +
  8.3607 +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
  8.3608 +    VkDevice                                    device,
  8.3609 +    VkSwapchainKHR                              swapchain,
  8.3610 +    uint64_t                                    timeout,
  8.3611 +    VkSemaphore                                 semaphore,
  8.3612 +    VkFence                                     fence,
  8.3613 +    uint32_t*                                   pImageIndex);
  8.3614 +
  8.3615 +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
  8.3616 +    VkQueue                                     queue,
  8.3617 +    const VkPresentInfoKHR*                     pPresentInfo);
  8.3618 +#endif
  8.3619 +
  8.3620 +#define VK_KHR_display 1
  8.3621 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
  8.3622 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
  8.3623 +
  8.3624 +#define VK_KHR_DISPLAY_SPEC_VERSION       21
  8.3625 +#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
  8.3626 +
  8.3627 +
  8.3628 +typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
  8.3629 +    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
  8.3630 +    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
  8.3631 +    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
  8.3632 +    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
  8.3633 +    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.3634 +} VkDisplayPlaneAlphaFlagBitsKHR;
  8.3635 +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
  8.3636 +typedef VkFlags VkDisplayModeCreateFlagsKHR;
  8.3637 +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
  8.3638 +
  8.3639 +typedef struct VkDisplayPropertiesKHR {
  8.3640 +    VkDisplayKHR                  display;
  8.3641 +    const char*                   displayName;
  8.3642 +    VkExtent2D                    physicalDimensions;
  8.3643 +    VkExtent2D                    physicalResolution;
  8.3644 +    VkSurfaceTransformFlagsKHR    supportedTransforms;
  8.3645 +    VkBool32                      planeReorderPossible;
  8.3646 +    VkBool32                      persistentContent;
  8.3647 +} VkDisplayPropertiesKHR;
  8.3648 +
  8.3649 +typedef struct VkDisplayModeParametersKHR {
  8.3650 +    VkExtent2D    visibleRegion;
  8.3651 +    uint32_t      refreshRate;
  8.3652 +} VkDisplayModeParametersKHR;
  8.3653 +
  8.3654 +typedef struct VkDisplayModePropertiesKHR {
  8.3655 +    VkDisplayModeKHR              displayMode;
  8.3656 +    VkDisplayModeParametersKHR    parameters;
  8.3657 +} VkDisplayModePropertiesKHR;
  8.3658 +
  8.3659 +typedef struct VkDisplayModeCreateInfoKHR {
  8.3660 +    VkStructureType                sType;
  8.3661 +    const void*                    pNext;
  8.3662 +    VkDisplayModeCreateFlagsKHR    flags;
  8.3663 +    VkDisplayModeParametersKHR     parameters;
  8.3664 +} VkDisplayModeCreateInfoKHR;
  8.3665 +
  8.3666 +typedef struct VkDisplayPlaneCapabilitiesKHR {
  8.3667 +    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
  8.3668 +    VkOffset2D                     minSrcPosition;
  8.3669 +    VkOffset2D                     maxSrcPosition;
  8.3670 +    VkExtent2D                     minSrcExtent;
  8.3671 +    VkExtent2D                     maxSrcExtent;
  8.3672 +    VkOffset2D                     minDstPosition;
  8.3673 +    VkOffset2D                     maxDstPosition;
  8.3674 +    VkExtent2D                     minDstExtent;
  8.3675 +    VkExtent2D                     maxDstExtent;
  8.3676 +} VkDisplayPlaneCapabilitiesKHR;
  8.3677 +
  8.3678 +typedef struct VkDisplayPlanePropertiesKHR {
  8.3679 +    VkDisplayKHR    currentDisplay;
  8.3680 +    uint32_t        currentStackIndex;
  8.3681 +} VkDisplayPlanePropertiesKHR;
  8.3682 +
  8.3683 +typedef struct VkDisplaySurfaceCreateInfoKHR {
  8.3684 +    VkStructureType                   sType;
  8.3685 +    const void*                       pNext;
  8.3686 +    VkDisplaySurfaceCreateFlagsKHR    flags;
  8.3687 +    VkDisplayModeKHR                  displayMode;
  8.3688 +    uint32_t                          planeIndex;
  8.3689 +    uint32_t                          planeStackIndex;
  8.3690 +    VkSurfaceTransformFlagBitsKHR     transform;
  8.3691 +    float                             globalAlpha;
  8.3692 +    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
  8.3693 +    VkExtent2D                        imageExtent;
  8.3694 +} VkDisplaySurfaceCreateInfoKHR;
  8.3695 +
  8.3696 +
  8.3697 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
  8.3698 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
  8.3699 +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
  8.3700 +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
  8.3701 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
  8.3702 +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
  8.3703 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3704 +
  8.3705 +#ifndef VK_NO_PROTOTYPES
  8.3706 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
  8.3707 +    VkPhysicalDevice                            physicalDevice,
  8.3708 +    uint32_t*                                   pPropertyCount,
  8.3709 +    VkDisplayPropertiesKHR*                     pProperties);
  8.3710 +
  8.3711 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
  8.3712 +    VkPhysicalDevice                            physicalDevice,
  8.3713 +    uint32_t*                                   pPropertyCount,
  8.3714 +    VkDisplayPlanePropertiesKHR*                pProperties);
  8.3715 +
  8.3716 +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
  8.3717 +    VkPhysicalDevice                            physicalDevice,
  8.3718 +    uint32_t                                    planeIndex,
  8.3719 +    uint32_t*                                   pDisplayCount,
  8.3720 +    VkDisplayKHR*                               pDisplays);
  8.3721 +
  8.3722 +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
  8.3723 +    VkPhysicalDevice                            physicalDevice,
  8.3724 +    VkDisplayKHR                                display,
  8.3725 +    uint32_t*                                   pPropertyCount,
  8.3726 +    VkDisplayModePropertiesKHR*                 pProperties);
  8.3727 +
  8.3728 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
  8.3729 +    VkPhysicalDevice                            physicalDevice,
  8.3730 +    VkDisplayKHR                                display,
  8.3731 +    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
  8.3732 +    const VkAllocationCallbacks*                pAllocator,
  8.3733 +    VkDisplayModeKHR*                           pMode);
  8.3734 +
  8.3735 +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
  8.3736 +    VkPhysicalDevice                            physicalDevice,
  8.3737 +    VkDisplayModeKHR                            mode,
  8.3738 +    uint32_t                                    planeIndex,
  8.3739 +    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
  8.3740 +
  8.3741 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
  8.3742 +    VkInstance                                  instance,
  8.3743 +    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
  8.3744 +    const VkAllocationCallbacks*                pAllocator,
  8.3745 +    VkSurfaceKHR*                               pSurface);
  8.3746 +#endif
  8.3747 +
  8.3748 +#define VK_KHR_display_swapchain 1
  8.3749 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
  8.3750 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
  8.3751 +
  8.3752 +typedef struct VkDisplayPresentInfoKHR {
  8.3753 +    VkStructureType    sType;
  8.3754 +    const void*        pNext;
  8.3755 +    VkRect2D           srcRect;
  8.3756 +    VkRect2D           dstRect;
  8.3757 +    VkBool32           persistent;
  8.3758 +} VkDisplayPresentInfoKHR;
  8.3759 +
  8.3760 +
  8.3761 +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
  8.3762 +
  8.3763 +#ifndef VK_NO_PROTOTYPES
  8.3764 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
  8.3765 +    VkDevice                                    device,
  8.3766 +    uint32_t                                    swapchainCount,
  8.3767 +    const VkSwapchainCreateInfoKHR*             pCreateInfos,
  8.3768 +    const VkAllocationCallbacks*                pAllocator,
  8.3769 +    VkSwapchainKHR*                             pSwapchains);
  8.3770 +#endif
  8.3771 +
  8.3772 +#ifdef VK_USE_PLATFORM_XLIB_KHR
  8.3773 +#define VK_KHR_xlib_surface 1
  8.3774 +#include <X11/Xlib.h>
  8.3775 +
  8.3776 +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
  8.3777 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
  8.3778 +
  8.3779 +typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
  8.3780 +
  8.3781 +typedef struct VkXlibSurfaceCreateInfoKHR {
  8.3782 +    VkStructureType                sType;
  8.3783 +    const void*                    pNext;
  8.3784 +    VkXlibSurfaceCreateFlagsKHR    flags;
  8.3785 +    Display*                       dpy;
  8.3786 +    Window                         window;
  8.3787 +} VkXlibSurfaceCreateInfoKHR;
  8.3788 +
  8.3789 +
  8.3790 +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3791 +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
  8.3792 +
  8.3793 +#ifndef VK_NO_PROTOTYPES
  8.3794 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
  8.3795 +    VkInstance                                  instance,
  8.3796 +    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
  8.3797 +    const VkAllocationCallbacks*                pAllocator,
  8.3798 +    VkSurfaceKHR*                               pSurface);
  8.3799 +
  8.3800 +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
  8.3801 +    VkPhysicalDevice                            physicalDevice,
  8.3802 +    uint32_t                                    queueFamilyIndex,
  8.3803 +    Display*                                    dpy,
  8.3804 +    VisualID                                    visualID);
  8.3805 +#endif
  8.3806 +#endif /* VK_USE_PLATFORM_XLIB_KHR */
  8.3807 +
  8.3808 +#ifdef VK_USE_PLATFORM_XCB_KHR
  8.3809 +#define VK_KHR_xcb_surface 1
  8.3810 +#include <xcb/xcb.h>
  8.3811 +
  8.3812 +#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
  8.3813 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
  8.3814 +
  8.3815 +typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
  8.3816 +
  8.3817 +typedef struct VkXcbSurfaceCreateInfoKHR {
  8.3818 +    VkStructureType               sType;
  8.3819 +    const void*                   pNext;
  8.3820 +    VkXcbSurfaceCreateFlagsKHR    flags;
  8.3821 +    xcb_connection_t*             connection;
  8.3822 +    xcb_window_t                  window;
  8.3823 +} VkXcbSurfaceCreateInfoKHR;
  8.3824 +
  8.3825 +
  8.3826 +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3827 +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
  8.3828 +
  8.3829 +#ifndef VK_NO_PROTOTYPES
  8.3830 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
  8.3831 +    VkInstance                                  instance,
  8.3832 +    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
  8.3833 +    const VkAllocationCallbacks*                pAllocator,
  8.3834 +    VkSurfaceKHR*                               pSurface);
  8.3835 +
  8.3836 +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
  8.3837 +    VkPhysicalDevice                            physicalDevice,
  8.3838 +    uint32_t                                    queueFamilyIndex,
  8.3839 +    xcb_connection_t*                           connection,
  8.3840 +    xcb_visualid_t                              visual_id);
  8.3841 +#endif
  8.3842 +#endif /* VK_USE_PLATFORM_XCB_KHR */
  8.3843 +
  8.3844 +#ifdef VK_USE_PLATFORM_WAYLAND_KHR
  8.3845 +#define VK_KHR_wayland_surface 1
  8.3846 +#include <wayland-client.h>
  8.3847 +
  8.3848 +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
  8.3849 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
  8.3850 +
  8.3851 +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
  8.3852 +
  8.3853 +typedef struct VkWaylandSurfaceCreateInfoKHR {
  8.3854 +    VkStructureType                   sType;
  8.3855 +    const void*                       pNext;
  8.3856 +    VkWaylandSurfaceCreateFlagsKHR    flags;
  8.3857 +    struct wl_display*                display;
  8.3858 +    struct wl_surface*                surface;
  8.3859 +} VkWaylandSurfaceCreateInfoKHR;
  8.3860 +
  8.3861 +
  8.3862 +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3863 +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
  8.3864 +
  8.3865 +#ifndef VK_NO_PROTOTYPES
  8.3866 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
  8.3867 +    VkInstance                                  instance,
  8.3868 +    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
  8.3869 +    const VkAllocationCallbacks*                pAllocator,
  8.3870 +    VkSurfaceKHR*                               pSurface);
  8.3871 +
  8.3872 +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
  8.3873 +    VkPhysicalDevice                            physicalDevice,
  8.3874 +    uint32_t                                    queueFamilyIndex,
  8.3875 +    struct wl_display*                          display);
  8.3876 +#endif
  8.3877 +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
  8.3878 +
  8.3879 +#ifdef VK_USE_PLATFORM_MIR_KHR
  8.3880 +#define VK_KHR_mir_surface 1
  8.3881 +#include <mir_toolkit/client_types.h>
  8.3882 +
  8.3883 +#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
  8.3884 +#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
  8.3885 +
  8.3886 +typedef VkFlags VkMirSurfaceCreateFlagsKHR;
  8.3887 +
  8.3888 +typedef struct VkMirSurfaceCreateInfoKHR {
  8.3889 +    VkStructureType               sType;
  8.3890 +    const void*                   pNext;
  8.3891 +    VkMirSurfaceCreateFlagsKHR    flags;
  8.3892 +    MirConnection*                connection;
  8.3893 +    MirSurface*                   mirSurface;
  8.3894 +} VkMirSurfaceCreateInfoKHR;
  8.3895 +
  8.3896 +
  8.3897 +typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3898 +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
  8.3899 +
  8.3900 +#ifndef VK_NO_PROTOTYPES
  8.3901 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
  8.3902 +    VkInstance                                  instance,
  8.3903 +    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
  8.3904 +    const VkAllocationCallbacks*                pAllocator,
  8.3905 +    VkSurfaceKHR*                               pSurface);
  8.3906 +
  8.3907 +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
  8.3908 +    VkPhysicalDevice                            physicalDevice,
  8.3909 +    uint32_t                                    queueFamilyIndex,
  8.3910 +    MirConnection*                              connection);
  8.3911 +#endif
  8.3912 +#endif /* VK_USE_PLATFORM_MIR_KHR */
  8.3913 +
  8.3914 +#ifdef VK_USE_PLATFORM_ANDROID_KHR
  8.3915 +#define VK_KHR_android_surface 1
  8.3916 +#include <android/native_window.h>
  8.3917 +
  8.3918 +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
  8.3919 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
  8.3920 +
  8.3921 +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
  8.3922 +
  8.3923 +typedef struct VkAndroidSurfaceCreateInfoKHR {
  8.3924 +    VkStructureType                   sType;
  8.3925 +    const void*                       pNext;
  8.3926 +    VkAndroidSurfaceCreateFlagsKHR    flags;
  8.3927 +    ANativeWindow*                    window;
  8.3928 +} VkAndroidSurfaceCreateInfoKHR;
  8.3929 +
  8.3930 +
  8.3931 +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3932 +
  8.3933 +#ifndef VK_NO_PROTOTYPES
  8.3934 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
  8.3935 +    VkInstance                                  instance,
  8.3936 +    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
  8.3937 +    const VkAllocationCallbacks*                pAllocator,
  8.3938 +    VkSurfaceKHR*                               pSurface);
  8.3939 +#endif
  8.3940 +#endif /* VK_USE_PLATFORM_ANDROID_KHR */
  8.3941 +
  8.3942 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.3943 +#define VK_KHR_win32_surface 1
  8.3944 +#include <windows.h>
  8.3945 +
  8.3946 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
  8.3947 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
  8.3948 +
  8.3949 +typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
  8.3950 +
  8.3951 +typedef struct VkWin32SurfaceCreateInfoKHR {
  8.3952 +    VkStructureType                 sType;
  8.3953 +    const void*                     pNext;
  8.3954 +    VkWin32SurfaceCreateFlagsKHR    flags;
  8.3955 +    HINSTANCE                       hinstance;
  8.3956 +    HWND                            hwnd;
  8.3957 +} VkWin32SurfaceCreateInfoKHR;
  8.3958 +
  8.3959 +
  8.3960 +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.3961 +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
  8.3962 +
  8.3963 +#ifndef VK_NO_PROTOTYPES
  8.3964 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
  8.3965 +    VkInstance                                  instance,
  8.3966 +    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
  8.3967 +    const VkAllocationCallbacks*                pAllocator,
  8.3968 +    VkSurfaceKHR*                               pSurface);
  8.3969 +
  8.3970 +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
  8.3971 +    VkPhysicalDevice                            physicalDevice,
  8.3972 +    uint32_t                                    queueFamilyIndex);
  8.3973 +#endif
  8.3974 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.3975 +
  8.3976 +#define VK_KHR_sampler_mirror_clamp_to_edge 1
  8.3977 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
  8.3978 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
  8.3979 +
  8.3980 +
  8.3981 +#define VK_KHR_get_physical_device_properties2 1
  8.3982 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
  8.3983 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
  8.3984 +
  8.3985 +typedef struct VkPhysicalDeviceFeatures2KHR {
  8.3986 +    VkStructureType             sType;
  8.3987 +    void*                       pNext;
  8.3988 +    VkPhysicalDeviceFeatures    features;
  8.3989 +} VkPhysicalDeviceFeatures2KHR;
  8.3990 +
  8.3991 +typedef struct VkPhysicalDeviceProperties2KHR {
  8.3992 +    VkStructureType               sType;
  8.3993 +    void*                         pNext;
  8.3994 +    VkPhysicalDeviceProperties    properties;
  8.3995 +} VkPhysicalDeviceProperties2KHR;
  8.3996 +
  8.3997 +typedef struct VkFormatProperties2KHR {
  8.3998 +    VkStructureType       sType;
  8.3999 +    void*                 pNext;
  8.4000 +    VkFormatProperties    formatProperties;
  8.4001 +} VkFormatProperties2KHR;
  8.4002 +
  8.4003 +typedef struct VkImageFormatProperties2KHR {
  8.4004 +    VkStructureType            sType;
  8.4005 +    void*                      pNext;
  8.4006 +    VkImageFormatProperties    imageFormatProperties;
  8.4007 +} VkImageFormatProperties2KHR;
  8.4008 +
  8.4009 +typedef struct VkPhysicalDeviceImageFormatInfo2KHR {
  8.4010 +    VkStructureType       sType;
  8.4011 +    const void*           pNext;
  8.4012 +    VkFormat              format;
  8.4013 +    VkImageType           type;
  8.4014 +    VkImageTiling         tiling;
  8.4015 +    VkImageUsageFlags     usage;
  8.4016 +    VkImageCreateFlags    flags;
  8.4017 +} VkPhysicalDeviceImageFormatInfo2KHR;
  8.4018 +
  8.4019 +typedef struct VkQueueFamilyProperties2KHR {
  8.4020 +    VkStructureType            sType;
  8.4021 +    void*                      pNext;
  8.4022 +    VkQueueFamilyProperties    queueFamilyProperties;
  8.4023 +} VkQueueFamilyProperties2KHR;
  8.4024 +
  8.4025 +typedef struct VkPhysicalDeviceMemoryProperties2KHR {
  8.4026 +    VkStructureType                     sType;
  8.4027 +    void*                               pNext;
  8.4028 +    VkPhysicalDeviceMemoryProperties    memoryProperties;
  8.4029 +} VkPhysicalDeviceMemoryProperties2KHR;
  8.4030 +
  8.4031 +typedef struct VkSparseImageFormatProperties2KHR {
  8.4032 +    VkStructureType                  sType;
  8.4033 +    void*                            pNext;
  8.4034 +    VkSparseImageFormatProperties    properties;
  8.4035 +} VkSparseImageFormatProperties2KHR;
  8.4036 +
  8.4037 +typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
  8.4038 +    VkStructureType          sType;
  8.4039 +    const void*              pNext;
  8.4040 +    VkFormat                 format;
  8.4041 +    VkImageType              type;
  8.4042 +    VkSampleCountFlagBits    samples;
  8.4043 +    VkImageUsageFlags        usage;
  8.4044 +    VkImageTiling            tiling;
  8.4045 +} VkPhysicalDeviceSparseImageFormatInfo2KHR;
  8.4046 +
  8.4047 +
  8.4048 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
  8.4049 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
  8.4050 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
  8.4051 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
  8.4052 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
  8.4053 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
  8.4054 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
  8.4055 +
  8.4056 +#ifndef VK_NO_PROTOTYPES
  8.4057 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
  8.4058 +    VkPhysicalDevice                            physicalDevice,
  8.4059 +    VkPhysicalDeviceFeatures2KHR*               pFeatures);
  8.4060 +
  8.4061 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
  8.4062 +    VkPhysicalDevice                            physicalDevice,
  8.4063 +    VkPhysicalDeviceProperties2KHR*             pProperties);
  8.4064 +
  8.4065 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
  8.4066 +    VkPhysicalDevice                            physicalDevice,
  8.4067 +    VkFormat                                    format,
  8.4068 +    VkFormatProperties2KHR*                     pFormatProperties);
  8.4069 +
  8.4070 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
  8.4071 +    VkPhysicalDevice                            physicalDevice,
  8.4072 +    const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
  8.4073 +    VkImageFormatProperties2KHR*                pImageFormatProperties);
  8.4074 +
  8.4075 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
  8.4076 +    VkPhysicalDevice                            physicalDevice,
  8.4077 +    uint32_t*                                   pQueueFamilyPropertyCount,
  8.4078 +    VkQueueFamilyProperties2KHR*                pQueueFamilyProperties);
  8.4079 +
  8.4080 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
  8.4081 +    VkPhysicalDevice                            physicalDevice,
  8.4082 +    VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties);
  8.4083 +
  8.4084 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
  8.4085 +    VkPhysicalDevice                            physicalDevice,
  8.4086 +    const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
  8.4087 +    uint32_t*                                   pPropertyCount,
  8.4088 +    VkSparseImageFormatProperties2KHR*          pProperties);
  8.4089 +#endif
  8.4090 +
  8.4091 +#define VK_KHR_shader_draw_parameters 1
  8.4092 +#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
  8.4093 +#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
  8.4094 +
  8.4095 +
  8.4096 +#define VK_KHR_maintenance1 1
  8.4097 +#define VK_KHR_MAINTENANCE1_SPEC_VERSION  1
  8.4098 +#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
  8.4099 +
  8.4100 +typedef VkFlags VkCommandPoolTrimFlagsKHR;
  8.4101 +
  8.4102 +typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
  8.4103 +
  8.4104 +#ifndef VK_NO_PROTOTYPES
  8.4105 +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
  8.4106 +    VkDevice                                    device,
  8.4107 +    VkCommandPool                               commandPool,
  8.4108 +    VkCommandPoolTrimFlagsKHR                   flags);
  8.4109 +#endif
  8.4110 +
  8.4111 +#define VK_KHR_external_memory_capabilities 1
  8.4112 +#define VK_LUID_SIZE_KHR                  8
  8.4113 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
  8.4114 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
  8.4115 +
  8.4116 +
  8.4117 +typedef enum VkExternalMemoryHandleTypeFlagBitsKHR {
  8.4118 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
  8.4119 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
  8.4120 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
  8.4121 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008,
  8.4122 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010,
  8.4123 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020,
  8.4124 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040,
  8.4125 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4126 +} VkExternalMemoryHandleTypeFlagBitsKHR;
  8.4127 +typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR;
  8.4128 +
  8.4129 +typedef enum VkExternalMemoryFeatureFlagBitsKHR {
  8.4130 +    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001,
  8.4131 +    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002,
  8.4132 +    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004,
  8.4133 +    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4134 +} VkExternalMemoryFeatureFlagBitsKHR;
  8.4135 +typedef VkFlags VkExternalMemoryFeatureFlagsKHR;
  8.4136 +
  8.4137 +typedef struct VkExternalMemoryPropertiesKHR {
  8.4138 +    VkExternalMemoryFeatureFlagsKHR       externalMemoryFeatures;
  8.4139 +    VkExternalMemoryHandleTypeFlagsKHR    exportFromImportedHandleTypes;
  8.4140 +    VkExternalMemoryHandleTypeFlagsKHR    compatibleHandleTypes;
  8.4141 +} VkExternalMemoryPropertiesKHR;
  8.4142 +
  8.4143 +typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR {
  8.4144 +    VkStructureType                          sType;
  8.4145 +    const void*                              pNext;
  8.4146 +    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  8.4147 +} VkPhysicalDeviceExternalImageFormatInfoKHR;
  8.4148 +
  8.4149 +typedef struct VkExternalImageFormatPropertiesKHR {
  8.4150 +    VkStructureType                  sType;
  8.4151 +    void*                            pNext;
  8.4152 +    VkExternalMemoryPropertiesKHR    externalMemoryProperties;
  8.4153 +} VkExternalImageFormatPropertiesKHR;
  8.4154 +
  8.4155 +typedef struct VkPhysicalDeviceExternalBufferInfoKHR {
  8.4156 +    VkStructureType                          sType;
  8.4157 +    const void*                              pNext;
  8.4158 +    VkBufferCreateFlags                      flags;
  8.4159 +    VkBufferUsageFlags                       usage;
  8.4160 +    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  8.4161 +} VkPhysicalDeviceExternalBufferInfoKHR;
  8.4162 +
  8.4163 +typedef struct VkExternalBufferPropertiesKHR {
  8.4164 +    VkStructureType                  sType;
  8.4165 +    void*                            pNext;
  8.4166 +    VkExternalMemoryPropertiesKHR    externalMemoryProperties;
  8.4167 +} VkExternalBufferPropertiesKHR;
  8.4168 +
  8.4169 +typedef struct VkPhysicalDeviceIDPropertiesKHR {
  8.4170 +    VkStructureType    sType;
  8.4171 +    void*              pNext;
  8.4172 +    uint8_t            deviceUUID[VK_UUID_SIZE];
  8.4173 +    uint8_t            driverUUID[VK_UUID_SIZE];
  8.4174 +    uint8_t            deviceLUID[VK_LUID_SIZE_KHR];
  8.4175 +    uint32_t           deviceNodeMask;
  8.4176 +    VkBool32           deviceLUIDValid;
  8.4177 +} VkPhysicalDeviceIDPropertiesKHR;
  8.4178 +
  8.4179 +
  8.4180 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties);
  8.4181 +
  8.4182 +#ifndef VK_NO_PROTOTYPES
  8.4183 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
  8.4184 +    VkPhysicalDevice                            physicalDevice,
  8.4185 +    const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
  8.4186 +    VkExternalBufferPropertiesKHR*              pExternalBufferProperties);
  8.4187 +#endif
  8.4188 +
  8.4189 +#define VK_KHR_external_memory 1
  8.4190 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
  8.4191 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
  8.4192 +#define VK_QUEUE_FAMILY_EXTERNAL_KHR      (~0U-1)
  8.4193 +
  8.4194 +typedef struct VkExternalMemoryImageCreateInfoKHR {
  8.4195 +    VkStructureType                       sType;
  8.4196 +    const void*                           pNext;
  8.4197 +    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
  8.4198 +} VkExternalMemoryImageCreateInfoKHR;
  8.4199 +
  8.4200 +typedef struct VkExternalMemoryBufferCreateInfoKHR {
  8.4201 +    VkStructureType                       sType;
  8.4202 +    const void*                           pNext;
  8.4203 +    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
  8.4204 +} VkExternalMemoryBufferCreateInfoKHR;
  8.4205 +
  8.4206 +typedef struct VkExportMemoryAllocateInfoKHR {
  8.4207 +    VkStructureType                       sType;
  8.4208 +    const void*                           pNext;
  8.4209 +    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
  8.4210 +} VkExportMemoryAllocateInfoKHR;
  8.4211 +
  8.4212 +
  8.4213 +
  8.4214 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.4215 +#define VK_KHR_external_memory_win32 1
  8.4216 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
  8.4217 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
  8.4218 +
  8.4219 +typedef struct VkImportMemoryWin32HandleInfoKHR {
  8.4220 +    VkStructureType                          sType;
  8.4221 +    const void*                              pNext;
  8.4222 +    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  8.4223 +    HANDLE                                   handle;
  8.4224 +    LPCWSTR                                  name;
  8.4225 +} VkImportMemoryWin32HandleInfoKHR;
  8.4226 +
  8.4227 +typedef struct VkExportMemoryWin32HandleInfoKHR {
  8.4228 +    VkStructureType               sType;
  8.4229 +    const void*                   pNext;
  8.4230 +    const SECURITY_ATTRIBUTES*    pAttributes;
  8.4231 +    DWORD                         dwAccess;
  8.4232 +    LPCWSTR                       name;
  8.4233 +} VkExportMemoryWin32HandleInfoKHR;
  8.4234 +
  8.4235 +typedef struct VkMemoryWin32HandlePropertiesKHR {
  8.4236 +    VkStructureType    sType;
  8.4237 +    void*              pNext;
  8.4238 +    uint32_t           memoryTypeBits;
  8.4239 +} VkMemoryWin32HandlePropertiesKHR;
  8.4240 +
  8.4241 +typedef struct VkMemoryGetWin32HandleInfoKHR {
  8.4242 +    VkStructureType                          sType;
  8.4243 +    const void*                              pNext;
  8.4244 +    VkDeviceMemory                           memory;
  8.4245 +    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  8.4246 +} VkMemoryGetWin32HandleInfoKHR;
  8.4247 +
  8.4248 +
  8.4249 +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
  8.4250 +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
  8.4251 +
  8.4252 +#ifndef VK_NO_PROTOTYPES
  8.4253 +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
  8.4254 +    VkDevice                                    device,
  8.4255 +    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
  8.4256 +    HANDLE*                                     pHandle);
  8.4257 +
  8.4258 +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
  8.4259 +    VkDevice                                    device,
  8.4260 +    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
  8.4261 +    HANDLE                                      handle,
  8.4262 +    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
  8.4263 +#endif
  8.4264 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.4265 +
  8.4266 +#define VK_KHR_external_memory_fd 1
  8.4267 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
  8.4268 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
  8.4269 +
  8.4270 +typedef struct VkImportMemoryFdInfoKHR {
  8.4271 +    VkStructureType                          sType;
  8.4272 +    const void*                              pNext;
  8.4273 +    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  8.4274 +    int                                      fd;
  8.4275 +} VkImportMemoryFdInfoKHR;
  8.4276 +
  8.4277 +typedef struct VkMemoryFdPropertiesKHR {
  8.4278 +    VkStructureType    sType;
  8.4279 +    void*              pNext;
  8.4280 +    uint32_t           memoryTypeBits;
  8.4281 +} VkMemoryFdPropertiesKHR;
  8.4282 +
  8.4283 +typedef struct VkMemoryGetFdInfoKHR {
  8.4284 +    VkStructureType                          sType;
  8.4285 +    const void*                              pNext;
  8.4286 +    VkDeviceMemory                           memory;
  8.4287 +    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  8.4288 +} VkMemoryGetFdInfoKHR;
  8.4289 +
  8.4290 +
  8.4291 +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
  8.4292 +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
  8.4293 +
  8.4294 +#ifndef VK_NO_PROTOTYPES
  8.4295 +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
  8.4296 +    VkDevice                                    device,
  8.4297 +    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
  8.4298 +    int*                                        pFd);
  8.4299 +
  8.4300 +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
  8.4301 +    VkDevice                                    device,
  8.4302 +    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
  8.4303 +    int                                         fd,
  8.4304 +    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
  8.4305 +#endif
  8.4306 +
  8.4307 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.4308 +#define VK_KHR_win32_keyed_mutex 1
  8.4309 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
  8.4310 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
  8.4311 +
  8.4312 +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
  8.4313 +    VkStructureType          sType;
  8.4314 +    const void*              pNext;
  8.4315 +    uint32_t                 acquireCount;
  8.4316 +    const VkDeviceMemory*    pAcquireSyncs;
  8.4317 +    const uint64_t*          pAcquireKeys;
  8.4318 +    const uint32_t*          pAcquireTimeouts;
  8.4319 +    uint32_t                 releaseCount;
  8.4320 +    const VkDeviceMemory*    pReleaseSyncs;
  8.4321 +    const uint64_t*          pReleaseKeys;
  8.4322 +} VkWin32KeyedMutexAcquireReleaseInfoKHR;
  8.4323 +
  8.4324 +
  8.4325 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.4326 +
  8.4327 +#define VK_KHR_external_semaphore_capabilities 1
  8.4328 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
  8.4329 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
  8.4330 +
  8.4331 +
  8.4332 +typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR {
  8.4333 +    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
  8.4334 +    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
  8.4335 +    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
  8.4336 +    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008,
  8.4337 +    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010,
  8.4338 +    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4339 +} VkExternalSemaphoreHandleTypeFlagBitsKHR;
  8.4340 +typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR;
  8.4341 +
  8.4342 +typedef enum VkExternalSemaphoreFeatureFlagBitsKHR {
  8.4343 +    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
  8.4344 +    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
  8.4345 +    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4346 +} VkExternalSemaphoreFeatureFlagBitsKHR;
  8.4347 +typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR;
  8.4348 +
  8.4349 +typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR {
  8.4350 +    VkStructureType                             sType;
  8.4351 +    const void*                                 pNext;
  8.4352 +    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  8.4353 +} VkPhysicalDeviceExternalSemaphoreInfoKHR;
  8.4354 +
  8.4355 +typedef struct VkExternalSemaphorePropertiesKHR {
  8.4356 +    VkStructureType                          sType;
  8.4357 +    void*                                    pNext;
  8.4358 +    VkExternalSemaphoreHandleTypeFlagsKHR    exportFromImportedHandleTypes;
  8.4359 +    VkExternalSemaphoreHandleTypeFlagsKHR    compatibleHandleTypes;
  8.4360 +    VkExternalSemaphoreFeatureFlagsKHR       externalSemaphoreFeatures;
  8.4361 +} VkExternalSemaphorePropertiesKHR;
  8.4362 +
  8.4363 +
  8.4364 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
  8.4365 +
  8.4366 +#ifndef VK_NO_PROTOTYPES
  8.4367 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
  8.4368 +    VkPhysicalDevice                            physicalDevice,
  8.4369 +    const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
  8.4370 +    VkExternalSemaphorePropertiesKHR*           pExternalSemaphoreProperties);
  8.4371 +#endif
  8.4372 +
  8.4373 +#define VK_KHR_external_semaphore 1
  8.4374 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
  8.4375 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
  8.4376 +
  8.4377 +
  8.4378 +typedef enum VkSemaphoreImportFlagBitsKHR {
  8.4379 +    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
  8.4380 +    VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4381 +} VkSemaphoreImportFlagBitsKHR;
  8.4382 +typedef VkFlags VkSemaphoreImportFlagsKHR;
  8.4383 +
  8.4384 +typedef struct VkExportSemaphoreCreateInfoKHR {
  8.4385 +    VkStructureType                          sType;
  8.4386 +    const void*                              pNext;
  8.4387 +    VkExternalSemaphoreHandleTypeFlagsKHR    handleTypes;
  8.4388 +} VkExportSemaphoreCreateInfoKHR;
  8.4389 +
  8.4390 +
  8.4391 +
  8.4392 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.4393 +#define VK_KHR_external_semaphore_win32 1
  8.4394 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
  8.4395 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
  8.4396 +
  8.4397 +typedef struct VkImportSemaphoreWin32HandleInfoKHR {
  8.4398 +    VkStructureType                             sType;
  8.4399 +    const void*                                 pNext;
  8.4400 +    VkSemaphore                                 semaphore;
  8.4401 +    VkSemaphoreImportFlagsKHR                   flags;
  8.4402 +    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  8.4403 +    HANDLE                                      handle;
  8.4404 +    LPCWSTR                                     name;
  8.4405 +} VkImportSemaphoreWin32HandleInfoKHR;
  8.4406 +
  8.4407 +typedef struct VkExportSemaphoreWin32HandleInfoKHR {
  8.4408 +    VkStructureType               sType;
  8.4409 +    const void*                   pNext;
  8.4410 +    const SECURITY_ATTRIBUTES*    pAttributes;
  8.4411 +    DWORD                         dwAccess;
  8.4412 +    LPCWSTR                       name;
  8.4413 +} VkExportSemaphoreWin32HandleInfoKHR;
  8.4414 +
  8.4415 +typedef struct VkD3D12FenceSubmitInfoKHR {
  8.4416 +    VkStructureType    sType;
  8.4417 +    const void*        pNext;
  8.4418 +    uint32_t           waitSemaphoreValuesCount;
  8.4419 +    const uint64_t*    pWaitSemaphoreValues;
  8.4420 +    uint32_t           signalSemaphoreValuesCount;
  8.4421 +    const uint64_t*    pSignalSemaphoreValues;
  8.4422 +} VkD3D12FenceSubmitInfoKHR;
  8.4423 +
  8.4424 +typedef struct VkSemaphoreGetWin32HandleInfoKHR {
  8.4425 +    VkStructureType                             sType;
  8.4426 +    const void*                                 pNext;
  8.4427 +    VkSemaphore                                 semaphore;
  8.4428 +    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  8.4429 +} VkSemaphoreGetWin32HandleInfoKHR;
  8.4430 +
  8.4431 +
  8.4432 +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
  8.4433 +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
  8.4434 +
  8.4435 +#ifndef VK_NO_PROTOTYPES
  8.4436 +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
  8.4437 +    VkDevice                                    device,
  8.4438 +    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
  8.4439 +
  8.4440 +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
  8.4441 +    VkDevice                                    device,
  8.4442 +    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
  8.4443 +    HANDLE*                                     pHandle);
  8.4444 +#endif
  8.4445 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.4446 +
  8.4447 +#define VK_KHR_external_semaphore_fd 1
  8.4448 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
  8.4449 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
  8.4450 +
  8.4451 +typedef struct VkImportSemaphoreFdInfoKHR {
  8.4452 +    VkStructureType                             sType;
  8.4453 +    const void*                                 pNext;
  8.4454 +    VkSemaphore                                 semaphore;
  8.4455 +    VkSemaphoreImportFlagsKHR                   flags;
  8.4456 +    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  8.4457 +    int                                         fd;
  8.4458 +} VkImportSemaphoreFdInfoKHR;
  8.4459 +
  8.4460 +typedef struct VkSemaphoreGetFdInfoKHR {
  8.4461 +    VkStructureType                             sType;
  8.4462 +    const void*                                 pNext;
  8.4463 +    VkSemaphore                                 semaphore;
  8.4464 +    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  8.4465 +} VkSemaphoreGetFdInfoKHR;
  8.4466 +
  8.4467 +
  8.4468 +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
  8.4469 +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
  8.4470 +
  8.4471 +#ifndef VK_NO_PROTOTYPES
  8.4472 +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
  8.4473 +    VkDevice                                    device,
  8.4474 +    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
  8.4475 +
  8.4476 +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
  8.4477 +    VkDevice                                    device,
  8.4478 +    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
  8.4479 +    int*                                        pFd);
  8.4480 +#endif
  8.4481 +
  8.4482 +#define VK_KHR_push_descriptor 1
  8.4483 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
  8.4484 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
  8.4485 +
  8.4486 +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
  8.4487 +    VkStructureType    sType;
  8.4488 +    void*              pNext;
  8.4489 +    uint32_t           maxPushDescriptors;
  8.4490 +} VkPhysicalDevicePushDescriptorPropertiesKHR;
  8.4491 +
  8.4492 +
  8.4493 +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
  8.4494 +
  8.4495 +#ifndef VK_NO_PROTOTYPES
  8.4496 +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
  8.4497 +    VkCommandBuffer                             commandBuffer,
  8.4498 +    VkPipelineBindPoint                         pipelineBindPoint,
  8.4499 +    VkPipelineLayout                            layout,
  8.4500 +    uint32_t                                    set,
  8.4501 +    uint32_t                                    descriptorWriteCount,
  8.4502 +    const VkWriteDescriptorSet*                 pDescriptorWrites);
  8.4503 +#endif
  8.4504 +
  8.4505 +#define VK_KHR_16bit_storage 1
  8.4506 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
  8.4507 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
  8.4508 +
  8.4509 +typedef struct VkPhysicalDevice16BitStorageFeaturesKHR {
  8.4510 +    VkStructureType    sType;
  8.4511 +    void*              pNext;
  8.4512 +    VkBool32           storageBuffer16BitAccess;
  8.4513 +    VkBool32           uniformAndStorageBuffer16BitAccess;
  8.4514 +    VkBool32           storagePushConstant16;
  8.4515 +    VkBool32           storageInputOutput16;
  8.4516 +} VkPhysicalDevice16BitStorageFeaturesKHR;
  8.4517 +
  8.4518 +
  8.4519 +
  8.4520 +#define VK_KHR_incremental_present 1
  8.4521 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
  8.4522 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
  8.4523 +
  8.4524 +typedef struct VkRectLayerKHR {
  8.4525 +    VkOffset2D    offset;
  8.4526 +    VkExtent2D    extent;
  8.4527 +    uint32_t      layer;
  8.4528 +} VkRectLayerKHR;
  8.4529 +
  8.4530 +typedef struct VkPresentRegionKHR {
  8.4531 +    uint32_t                 rectangleCount;
  8.4532 +    const VkRectLayerKHR*    pRectangles;
  8.4533 +} VkPresentRegionKHR;
  8.4534 +
  8.4535 +typedef struct VkPresentRegionsKHR {
  8.4536 +    VkStructureType              sType;
  8.4537 +    const void*                  pNext;
  8.4538 +    uint32_t                     swapchainCount;
  8.4539 +    const VkPresentRegionKHR*    pRegions;
  8.4540 +} VkPresentRegionsKHR;
  8.4541 +
  8.4542 +
  8.4543 +
  8.4544 +#define VK_KHR_descriptor_update_template 1
  8.4545 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
  8.4546 +
  8.4547 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
  8.4548 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
  8.4549 +
  8.4550 +
  8.4551 +typedef enum VkDescriptorUpdateTemplateTypeKHR {
  8.4552 +    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
  8.4553 +    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
  8.4554 +    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
  8.4555 +    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
  8.4556 +    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1),
  8.4557 +    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4558 +} VkDescriptorUpdateTemplateTypeKHR;
  8.4559 +
  8.4560 +typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
  8.4561 +
  8.4562 +typedef struct VkDescriptorUpdateTemplateEntryKHR {
  8.4563 +    uint32_t            dstBinding;
  8.4564 +    uint32_t            dstArrayElement;
  8.4565 +    uint32_t            descriptorCount;
  8.4566 +    VkDescriptorType    descriptorType;
  8.4567 +    size_t              offset;
  8.4568 +    size_t              stride;
  8.4569 +} VkDescriptorUpdateTemplateEntryKHR;
  8.4570 +
  8.4571 +typedef struct VkDescriptorUpdateTemplateCreateInfoKHR {
  8.4572 +    VkStructureType                              sType;
  8.4573 +    void*                                        pNext;
  8.4574 +    VkDescriptorUpdateTemplateCreateFlagsKHR     flags;
  8.4575 +    uint32_t                                     descriptorUpdateEntryCount;
  8.4576 +    const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries;
  8.4577 +    VkDescriptorUpdateTemplateTypeKHR            templateType;
  8.4578 +    VkDescriptorSetLayout                        descriptorSetLayout;
  8.4579 +    VkPipelineBindPoint                          pipelineBindPoint;
  8.4580 +    VkPipelineLayout                             pipelineLayout;
  8.4581 +    uint32_t                                     set;
  8.4582 +} VkDescriptorUpdateTemplateCreateInfoKHR;
  8.4583 +
  8.4584 +
  8.4585 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
  8.4586 +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
  8.4587 +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
  8.4588 +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
  8.4589 +
  8.4590 +#ifndef VK_NO_PROTOTYPES
  8.4591 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
  8.4592 +    VkDevice                                    device,
  8.4593 +    const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
  8.4594 +    const VkAllocationCallbacks*                pAllocator,
  8.4595 +    VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate);
  8.4596 +
  8.4597 +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
  8.4598 +    VkDevice                                    device,
  8.4599 +    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
  8.4600 +    const VkAllocationCallbacks*                pAllocator);
  8.4601 +
  8.4602 +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
  8.4603 +    VkDevice                                    device,
  8.4604 +    VkDescriptorSet                             descriptorSet,
  8.4605 +    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
  8.4606 +    const void*                                 pData);
  8.4607 +
  8.4608 +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
  8.4609 +    VkCommandBuffer                             commandBuffer,
  8.4610 +    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
  8.4611 +    VkPipelineLayout                            layout,
  8.4612 +    uint32_t                                    set,
  8.4613 +    const void*                                 pData);
  8.4614 +#endif
  8.4615 +
  8.4616 +#define VK_KHR_shared_presentable_image 1
  8.4617 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
  8.4618 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
  8.4619 +
  8.4620 +typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
  8.4621 +    VkStructureType      sType;
  8.4622 +    void*                pNext;
  8.4623 +    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
  8.4624 +} VkSharedPresentSurfaceCapabilitiesKHR;
  8.4625 +
  8.4626 +
  8.4627 +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
  8.4628 +
  8.4629 +#ifndef VK_NO_PROTOTYPES
  8.4630 +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
  8.4631 +    VkDevice                                    device,
  8.4632 +    VkSwapchainKHR                              swapchain);
  8.4633 +#endif
  8.4634 +
  8.4635 +#define VK_KHR_external_fence_capabilities 1
  8.4636 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
  8.4637 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
  8.4638 +
  8.4639 +
  8.4640 +typedef enum VkExternalFenceHandleTypeFlagBitsKHR {
  8.4641 +    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
  8.4642 +    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
  8.4643 +    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
  8.4644 +    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008,
  8.4645 +    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4646 +} VkExternalFenceHandleTypeFlagBitsKHR;
  8.4647 +typedef VkFlags VkExternalFenceHandleTypeFlagsKHR;
  8.4648 +
  8.4649 +typedef enum VkExternalFenceFeatureFlagBitsKHR {
  8.4650 +    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
  8.4651 +    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
  8.4652 +    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4653 +} VkExternalFenceFeatureFlagBitsKHR;
  8.4654 +typedef VkFlags VkExternalFenceFeatureFlagsKHR;
  8.4655 +
  8.4656 +typedef struct VkPhysicalDeviceExternalFenceInfoKHR {
  8.4657 +    VkStructureType                         sType;
  8.4658 +    const void*                             pNext;
  8.4659 +    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  8.4660 +} VkPhysicalDeviceExternalFenceInfoKHR;
  8.4661 +
  8.4662 +typedef struct VkExternalFencePropertiesKHR {
  8.4663 +    VkStructureType                      sType;
  8.4664 +    void*                                pNext;
  8.4665 +    VkExternalFenceHandleTypeFlagsKHR    exportFromImportedHandleTypes;
  8.4666 +    VkExternalFenceHandleTypeFlagsKHR    compatibleHandleTypes;
  8.4667 +    VkExternalFenceFeatureFlagsKHR       externalFenceFeatures;
  8.4668 +} VkExternalFencePropertiesKHR;
  8.4669 +
  8.4670 +
  8.4671 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties);
  8.4672 +
  8.4673 +#ifndef VK_NO_PROTOTYPES
  8.4674 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
  8.4675 +    VkPhysicalDevice                            physicalDevice,
  8.4676 +    const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
  8.4677 +    VkExternalFencePropertiesKHR*               pExternalFenceProperties);
  8.4678 +#endif
  8.4679 +
  8.4680 +#define VK_KHR_external_fence 1
  8.4681 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
  8.4682 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
  8.4683 +
  8.4684 +
  8.4685 +typedef enum VkFenceImportFlagBitsKHR {
  8.4686 +    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
  8.4687 +    VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  8.4688 +} VkFenceImportFlagBitsKHR;
  8.4689 +typedef VkFlags VkFenceImportFlagsKHR;
  8.4690 +
  8.4691 +typedef struct VkExportFenceCreateInfoKHR {
  8.4692 +    VkStructureType                      sType;
  8.4693 +    const void*                          pNext;
  8.4694 +    VkExternalFenceHandleTypeFlagsKHR    handleTypes;
  8.4695 +} VkExportFenceCreateInfoKHR;
  8.4696 +
  8.4697 +
  8.4698 +
  8.4699 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.4700 +#define VK_KHR_external_fence_win32 1
  8.4701 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
  8.4702 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
  8.4703 +
  8.4704 +typedef struct VkImportFenceWin32HandleInfoKHR {
  8.4705 +    VkStructureType                         sType;
  8.4706 +    const void*                             pNext;
  8.4707 +    VkFence                                 fence;
  8.4708 +    VkFenceImportFlagsKHR                   flags;
  8.4709 +    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  8.4710 +    HANDLE                                  handle;
  8.4711 +    LPCWSTR                                 name;
  8.4712 +} VkImportFenceWin32HandleInfoKHR;
  8.4713 +
  8.4714 +typedef struct VkExportFenceWin32HandleInfoKHR {
  8.4715 +    VkStructureType               sType;
  8.4716 +    const void*                   pNext;
  8.4717 +    const SECURITY_ATTRIBUTES*    pAttributes;
  8.4718 +    DWORD                         dwAccess;
  8.4719 +    LPCWSTR                       name;
  8.4720 +} VkExportFenceWin32HandleInfoKHR;
  8.4721 +
  8.4722 +typedef struct VkFenceGetWin32HandleInfoKHR {
  8.4723 +    VkStructureType                         sType;
  8.4724 +    const void*                             pNext;
  8.4725 +    VkFence                                 fence;
  8.4726 +    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  8.4727 +} VkFenceGetWin32HandleInfoKHR;
  8.4728 +
  8.4729 +
  8.4730 +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
  8.4731 +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
  8.4732 +
  8.4733 +#ifndef VK_NO_PROTOTYPES
  8.4734 +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
  8.4735 +    VkDevice                                    device,
  8.4736 +    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
  8.4737 +
  8.4738 +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
  8.4739 +    VkDevice                                    device,
  8.4740 +    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
  8.4741 +    HANDLE*                                     pHandle);
  8.4742 +#endif
  8.4743 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.4744 +
  8.4745 +#define VK_KHR_external_fence_fd 1
  8.4746 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
  8.4747 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
  8.4748 +
  8.4749 +typedef struct VkImportFenceFdInfoKHR {
  8.4750 +    VkStructureType                         sType;
  8.4751 +    const void*                             pNext;
  8.4752 +    VkFence                                 fence;
  8.4753 +    VkFenceImportFlagsKHR                   flags;
  8.4754 +    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  8.4755 +    int                                     fd;
  8.4756 +} VkImportFenceFdInfoKHR;
  8.4757 +
  8.4758 +typedef struct VkFenceGetFdInfoKHR {
  8.4759 +    VkStructureType                         sType;
  8.4760 +    const void*                             pNext;
  8.4761 +    VkFence                                 fence;
  8.4762 +    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  8.4763 +} VkFenceGetFdInfoKHR;
  8.4764 +
  8.4765 +
  8.4766 +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
  8.4767 +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
  8.4768 +
  8.4769 +#ifndef VK_NO_PROTOTYPES
  8.4770 +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
  8.4771 +    VkDevice                                    device,
  8.4772 +    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
  8.4773 +
  8.4774 +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
  8.4775 +    VkDevice                                    device,
  8.4776 +    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
  8.4777 +    int*                                        pFd);
  8.4778 +#endif
  8.4779 +
  8.4780 +#define VK_KHR_get_surface_capabilities2 1
  8.4781 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
  8.4782 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
  8.4783 +
  8.4784 +typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
  8.4785 +    VkStructureType    sType;
  8.4786 +    const void*        pNext;
  8.4787 +    VkSurfaceKHR       surface;
  8.4788 +} VkPhysicalDeviceSurfaceInfo2KHR;
  8.4789 +
  8.4790 +typedef struct VkSurfaceCapabilities2KHR {
  8.4791 +    VkStructureType             sType;
  8.4792 +    void*                       pNext;
  8.4793 +    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
  8.4794 +} VkSurfaceCapabilities2KHR;
  8.4795 +
  8.4796 +typedef struct VkSurfaceFormat2KHR {
  8.4797 +    VkStructureType       sType;
  8.4798 +    void*                 pNext;
  8.4799 +    VkSurfaceFormatKHR    surfaceFormat;
  8.4800 +} VkSurfaceFormat2KHR;
  8.4801 +
  8.4802 +
  8.4803 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
  8.4804 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
  8.4805 +
  8.4806 +#ifndef VK_NO_PROTOTYPES
  8.4807 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
  8.4808 +    VkPhysicalDevice                            physicalDevice,
  8.4809 +    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
  8.4810 +    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
  8.4811 +
  8.4812 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
  8.4813 +    VkPhysicalDevice                            physicalDevice,
  8.4814 +    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
  8.4815 +    uint32_t*                                   pSurfaceFormatCount,
  8.4816 +    VkSurfaceFormat2KHR*                        pSurfaceFormats);
  8.4817 +#endif
  8.4818 +
  8.4819 +#define VK_KHR_variable_pointers 1
  8.4820 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
  8.4821 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
  8.4822 +
  8.4823 +typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR {
  8.4824 +    VkStructureType    sType;
  8.4825 +    void*              pNext;
  8.4826 +    VkBool32           variablePointersStorageBuffer;
  8.4827 +    VkBool32           variablePointers;
  8.4828 +} VkPhysicalDeviceVariablePointerFeaturesKHR;
  8.4829 +
  8.4830 +
  8.4831 +
  8.4832 +#define VK_KHR_dedicated_allocation 1
  8.4833 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
  8.4834 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
  8.4835 +
  8.4836 +typedef struct VkMemoryDedicatedRequirementsKHR {
  8.4837 +    VkStructureType    sType;
  8.4838 +    void*              pNext;
  8.4839 +    VkBool32           prefersDedicatedAllocation;
  8.4840 +    VkBool32           requiresDedicatedAllocation;
  8.4841 +} VkMemoryDedicatedRequirementsKHR;
  8.4842 +
  8.4843 +typedef struct VkMemoryDedicatedAllocateInfoKHR {
  8.4844 +    VkStructureType    sType;
  8.4845 +    const void*        pNext;
  8.4846 +    VkImage            image;
  8.4847 +    VkBuffer           buffer;
  8.4848 +} VkMemoryDedicatedAllocateInfoKHR;
  8.4849 +
  8.4850 +
  8.4851 +
  8.4852 +#define VK_KHR_storage_buffer_storage_class 1
  8.4853 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
  8.4854 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
  8.4855 +
  8.4856 +
  8.4857 +#define VK_KHR_relaxed_block_layout 1
  8.4858 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
  8.4859 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
  8.4860 +
  8.4861 +
  8.4862 +#define VK_KHR_get_memory_requirements2 1
  8.4863 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
  8.4864 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
  8.4865 +
  8.4866 +typedef struct VkBufferMemoryRequirementsInfo2KHR {
  8.4867 +    VkStructureType    sType;
  8.4868 +    const void*        pNext;
  8.4869 +    VkBuffer           buffer;
  8.4870 +} VkBufferMemoryRequirementsInfo2KHR;
  8.4871 +
  8.4872 +typedef struct VkImageMemoryRequirementsInfo2KHR {
  8.4873 +    VkStructureType    sType;
  8.4874 +    const void*        pNext;
  8.4875 +    VkImage            image;
  8.4876 +} VkImageMemoryRequirementsInfo2KHR;
  8.4877 +
  8.4878 +typedef struct VkImageSparseMemoryRequirementsInfo2KHR {
  8.4879 +    VkStructureType    sType;
  8.4880 +    const void*        pNext;
  8.4881 +    VkImage            image;
  8.4882 +} VkImageSparseMemoryRequirementsInfo2KHR;
  8.4883 +
  8.4884 +typedef struct VkMemoryRequirements2KHR {
  8.4885 +    VkStructureType         sType;
  8.4886 +    void*                   pNext;
  8.4887 +    VkMemoryRequirements    memoryRequirements;
  8.4888 +} VkMemoryRequirements2KHR;
  8.4889 +
  8.4890 +typedef struct VkSparseImageMemoryRequirements2KHR {
  8.4891 +    VkStructureType                    sType;
  8.4892 +    void*                              pNext;
  8.4893 +    VkSparseImageMemoryRequirements    memoryRequirements;
  8.4894 +} VkSparseImageMemoryRequirements2KHR;
  8.4895 +
  8.4896 +
  8.4897 +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
  8.4898 +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
  8.4899 +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
  8.4900 +
  8.4901 +#ifndef VK_NO_PROTOTYPES
  8.4902 +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
  8.4903 +    VkDevice                                    device,
  8.4904 +    const VkImageMemoryRequirementsInfo2KHR*    pInfo,
  8.4905 +    VkMemoryRequirements2KHR*                   pMemoryRequirements);
  8.4906 +
  8.4907 +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
  8.4908 +    VkDevice                                    device,
  8.4909 +    const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
  8.4910 +    VkMemoryRequirements2KHR*                   pMemoryRequirements);
  8.4911 +
  8.4912 +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
  8.4913 +    VkDevice                                    device,
  8.4914 +    const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
  8.4915 +    uint32_t*                                   pSparseMemoryRequirementCount,
  8.4916 +    VkSparseImageMemoryRequirements2KHR*        pSparseMemoryRequirements);
  8.4917 +#endif
  8.4918 +
  8.4919 +#define VK_EXT_debug_report 1
  8.4920 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
  8.4921 +
  8.4922 +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  8
  8.4923 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
  8.4924 +#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
  8.4925 +#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT
  8.4926 +
  8.4927 +
  8.4928 +typedef enum VkDebugReportObjectTypeEXT {
  8.4929 +    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
  8.4930 +    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
  8.4931 +    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
  8.4932 +    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
  8.4933 +    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
  8.4934 +    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
  8.4935 +    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
  8.4936 +    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
  8.4937 +    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
  8.4938 +    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
  8.4939 +    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
  8.4940 +    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
  8.4941 +    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
  8.4942 +    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
  8.4943 +    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
  8.4944 +    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
  8.4945 +    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
  8.4946 +    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
  8.4947 +    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
  8.4948 +    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
  8.4949 +    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
  8.4950 +    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
  8.4951 +    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
  8.4952 +    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
  8.4953 +    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
  8.4954 +    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
  8.4955 +    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
  8.4956 +    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
  8.4957 +    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
  8.4958 +    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
  8.4959 +    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
  8.4960 +    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
  8.4961 +    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
  8.4962 +    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
  8.4963 +    VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
  8.4964 +    VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
  8.4965 +    VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
  8.4966 +    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
  8.4967 +} VkDebugReportObjectTypeEXT;
  8.4968 +
  8.4969 +
  8.4970 +typedef enum VkDebugReportFlagBitsEXT {
  8.4971 +    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
  8.4972 +    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
  8.4973 +    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
  8.4974 +    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
  8.4975 +    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
  8.4976 +    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
  8.4977 +} VkDebugReportFlagBitsEXT;
  8.4978 +typedef VkFlags VkDebugReportFlagsEXT;
  8.4979 +
  8.4980 +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
  8.4981 +    VkDebugReportFlagsEXT                       flags,
  8.4982 +    VkDebugReportObjectTypeEXT                  objectType,
  8.4983 +    uint64_t                                    object,
  8.4984 +    size_t                                      location,
  8.4985 +    int32_t                                     messageCode,
  8.4986 +    const char*                                 pLayerPrefix,
  8.4987 +    const char*                                 pMessage,
  8.4988 +    void*                                       pUserData);
  8.4989 +
  8.4990 +typedef struct VkDebugReportCallbackCreateInfoEXT {
  8.4991 +    VkStructureType                 sType;
  8.4992 +    const void*                     pNext;
  8.4993 +    VkDebugReportFlagsEXT           flags;
  8.4994 +    PFN_vkDebugReportCallbackEXT    pfnCallback;
  8.4995 +    void*                           pUserData;
  8.4996 +} VkDebugReportCallbackCreateInfoEXT;
  8.4997 +
  8.4998 +
  8.4999 +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
  8.5000 +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
  8.5001 +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);
  8.5002 +
  8.5003 +#ifndef VK_NO_PROTOTYPES
  8.5004 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
  8.5005 +    VkInstance                                  instance,
  8.5006 +    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
  8.5007 +    const VkAllocationCallbacks*                pAllocator,
  8.5008 +    VkDebugReportCallbackEXT*                   pCallback);
  8.5009 +
  8.5010 +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
  8.5011 +    VkInstance                                  instance,
  8.5012 +    VkDebugReportCallbackEXT                    callback,
  8.5013 +    const VkAllocationCallbacks*                pAllocator);
  8.5014 +
  8.5015 +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
  8.5016 +    VkInstance                                  instance,
  8.5017 +    VkDebugReportFlagsEXT                       flags,
  8.5018 +    VkDebugReportObjectTypeEXT                  objectType,
  8.5019 +    uint64_t                                    object,
  8.5020 +    size_t                                      location,
  8.5021 +    int32_t                                     messageCode,
  8.5022 +    const char*                                 pLayerPrefix,
  8.5023 +    const char*                                 pMessage);
  8.5024 +#endif
  8.5025 +
  8.5026 +#define VK_NV_glsl_shader 1
  8.5027 +#define VK_NV_GLSL_SHADER_SPEC_VERSION    1
  8.5028 +#define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
  8.5029 +
  8.5030 +
  8.5031 +#define VK_EXT_depth_range_unrestricted 1
  8.5032 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
  8.5033 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
  8.5034 +
  8.5035 +
  8.5036 +#define VK_IMG_filter_cubic 1
  8.5037 +#define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
  8.5038 +#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
  8.5039 +
  8.5040 +
  8.5041 +#define VK_AMD_rasterization_order 1
  8.5042 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
  8.5043 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
  8.5044 +
  8.5045 +
  8.5046 +typedef enum VkRasterizationOrderAMD {
  8.5047 +    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
  8.5048 +    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
  8.5049 +    VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
  8.5050 +    VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
  8.5051 +    VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
  8.5052 +    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
  8.5053 +} VkRasterizationOrderAMD;
  8.5054 +
  8.5055 +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
  8.5056 +    VkStructureType            sType;
  8.5057 +    const void*                pNext;
  8.5058 +    VkRasterizationOrderAMD    rasterizationOrder;
  8.5059 +} VkPipelineRasterizationStateRasterizationOrderAMD;
  8.5060 +
  8.5061 +
  8.5062 +
  8.5063 +#define VK_AMD_shader_trinary_minmax 1
  8.5064 +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
  8.5065 +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
  8.5066 +
  8.5067 +
  8.5068 +#define VK_AMD_shader_explicit_vertex_parameter 1
  8.5069 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
  8.5070 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
  8.5071 +
  8.5072 +
  8.5073 +#define VK_EXT_debug_marker 1
  8.5074 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
  8.5075 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
  8.5076 +
  8.5077 +typedef struct VkDebugMarkerObjectNameInfoEXT {
  8.5078 +    VkStructureType               sType;
  8.5079 +    const void*                   pNext;
  8.5080 +    VkDebugReportObjectTypeEXT    objectType;
  8.5081 +    uint64_t                      object;
  8.5082 +    const char*                   pObjectName;
  8.5083 +} VkDebugMarkerObjectNameInfoEXT;
  8.5084 +
  8.5085 +typedef struct VkDebugMarkerObjectTagInfoEXT {
  8.5086 +    VkStructureType               sType;
  8.5087 +    const void*                   pNext;
  8.5088 +    VkDebugReportObjectTypeEXT    objectType;
  8.5089 +    uint64_t                      object;
  8.5090 +    uint64_t                      tagName;
  8.5091 +    size_t                        tagSize;
  8.5092 +    const void*                   pTag;
  8.5093 +} VkDebugMarkerObjectTagInfoEXT;
  8.5094 +
  8.5095 +typedef struct VkDebugMarkerMarkerInfoEXT {
  8.5096 +    VkStructureType    sType;
  8.5097 +    const void*        pNext;
  8.5098 +    const char*        pMarkerName;
  8.5099 +    float              color[4];
  8.5100 +} VkDebugMarkerMarkerInfoEXT;
  8.5101 +
  8.5102 +
  8.5103 +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
  8.5104 +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
  8.5105 +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
  8.5106 +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
  8.5107 +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
  8.5108 +
  8.5109 +#ifndef VK_NO_PROTOTYPES
  8.5110 +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
  8.5111 +    VkDevice                                    device,
  8.5112 +    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
  8.5113 +
  8.5114 +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
  8.5115 +    VkDevice                                    device,
  8.5116 +    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
  8.5117 +
  8.5118 +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
  8.5119 +    VkCommandBuffer                             commandBuffer,
  8.5120 +    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
  8.5121 +
  8.5122 +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
  8.5123 +    VkCommandBuffer                             commandBuffer);
  8.5124 +
  8.5125 +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
  8.5126 +    VkCommandBuffer                             commandBuffer,
  8.5127 +    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
  8.5128 +#endif
  8.5129 +
  8.5130 +#define VK_AMD_gcn_shader 1
  8.5131 +#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
  8.5132 +#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
  8.5133 +
  8.5134 +
  8.5135 +#define VK_NV_dedicated_allocation 1
  8.5136 +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
  8.5137 +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
  8.5138 +
  8.5139 +typedef struct VkDedicatedAllocationImageCreateInfoNV {
  8.5140 +    VkStructureType    sType;
  8.5141 +    const void*        pNext;
  8.5142 +    VkBool32           dedicatedAllocation;
  8.5143 +} VkDedicatedAllocationImageCreateInfoNV;
  8.5144 +
  8.5145 +typedef struct VkDedicatedAllocationBufferCreateInfoNV {
  8.5146 +    VkStructureType    sType;
  8.5147 +    const void*        pNext;
  8.5148 +    VkBool32           dedicatedAllocation;
  8.5149 +} VkDedicatedAllocationBufferCreateInfoNV;
  8.5150 +
  8.5151 +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
  8.5152 +    VkStructureType    sType;
  8.5153 +    const void*        pNext;
  8.5154 +    VkImage            image;
  8.5155 +    VkBuffer           buffer;
  8.5156 +} VkDedicatedAllocationMemoryAllocateInfoNV;
  8.5157 +
  8.5158 +
  8.5159 +
  8.5160 +#define VK_AMD_draw_indirect_count 1
  8.5161 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
  8.5162 +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
  8.5163 +
  8.5164 +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
  8.5165 +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
  8.5166 +
  8.5167 +#ifndef VK_NO_PROTOTYPES
  8.5168 +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
  8.5169 +    VkCommandBuffer                             commandBuffer,
  8.5170 +    VkBuffer                                    buffer,
  8.5171 +    VkDeviceSize                                offset,
  8.5172 +    VkBuffer                                    countBuffer,
  8.5173 +    VkDeviceSize                                countBufferOffset,
  8.5174 +    uint32_t                                    maxDrawCount,
  8.5175 +    uint32_t                                    stride);
  8.5176 +
  8.5177 +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
  8.5178 +    VkCommandBuffer                             commandBuffer,
  8.5179 +    VkBuffer                                    buffer,
  8.5180 +    VkDeviceSize                                offset,
  8.5181 +    VkBuffer                                    countBuffer,
  8.5182 +    VkDeviceSize                                countBufferOffset,
  8.5183 +    uint32_t                                    maxDrawCount,
  8.5184 +    uint32_t                                    stride);
  8.5185 +#endif
  8.5186 +
  8.5187 +#define VK_AMD_negative_viewport_height 1
  8.5188 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
  8.5189 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
  8.5190 +
  8.5191 +
  8.5192 +#define VK_AMD_gpu_shader_half_float 1
  8.5193 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
  8.5194 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
  8.5195 +
  8.5196 +
  8.5197 +#define VK_AMD_shader_ballot 1
  8.5198 +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
  8.5199 +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
  8.5200 +
  8.5201 +
  8.5202 +#define VK_AMD_texture_gather_bias_lod 1
  8.5203 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
  8.5204 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
  8.5205 +
  8.5206 +typedef struct VkTextureLODGatherFormatPropertiesAMD {
  8.5207 +    VkStructureType    sType;
  8.5208 +    void*              pNext;
  8.5209 +    VkBool32           supportsTextureGatherLODBiasAMD;
  8.5210 +} VkTextureLODGatherFormatPropertiesAMD;
  8.5211 +
  8.5212 +
  8.5213 +
  8.5214 +#define VK_KHX_multiview 1
  8.5215 +#define VK_KHX_MULTIVIEW_SPEC_VERSION     1
  8.5216 +#define VK_KHX_MULTIVIEW_EXTENSION_NAME   "VK_KHX_multiview"
  8.5217 +
  8.5218 +typedef struct VkRenderPassMultiviewCreateInfoKHX {
  8.5219 +    VkStructureType    sType;
  8.5220 +    const void*        pNext;
  8.5221 +    uint32_t           subpassCount;
  8.5222 +    const uint32_t*    pViewMasks;
  8.5223 +    uint32_t           dependencyCount;
  8.5224 +    const int32_t*     pViewOffsets;
  8.5225 +    uint32_t           correlationMaskCount;
  8.5226 +    const uint32_t*    pCorrelationMasks;
  8.5227 +} VkRenderPassMultiviewCreateInfoKHX;
  8.5228 +
  8.5229 +typedef struct VkPhysicalDeviceMultiviewFeaturesKHX {
  8.5230 +    VkStructureType    sType;
  8.5231 +    void*              pNext;
  8.5232 +    VkBool32           multiview;
  8.5233 +    VkBool32           multiviewGeometryShader;
  8.5234 +    VkBool32           multiviewTessellationShader;
  8.5235 +} VkPhysicalDeviceMultiviewFeaturesKHX;
  8.5236 +
  8.5237 +typedef struct VkPhysicalDeviceMultiviewPropertiesKHX {
  8.5238 +    VkStructureType    sType;
  8.5239 +    void*              pNext;
  8.5240 +    uint32_t           maxMultiviewViewCount;
  8.5241 +    uint32_t           maxMultiviewInstanceIndex;
  8.5242 +} VkPhysicalDeviceMultiviewPropertiesKHX;
  8.5243 +
  8.5244 +
  8.5245 +
  8.5246 +#define VK_IMG_format_pvrtc 1
  8.5247 +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
  8.5248 +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
  8.5249 +
  8.5250 +
  8.5251 +#define VK_NV_external_memory_capabilities 1
  8.5252 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
  8.5253 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
  8.5254 +
  8.5255 +
  8.5256 +typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
  8.5257 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
  8.5258 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
  8.5259 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
  8.5260 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
  8.5261 +    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
  8.5262 +} VkExternalMemoryHandleTypeFlagBitsNV;
  8.5263 +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
  8.5264 +
  8.5265 +typedef enum VkExternalMemoryFeatureFlagBitsNV {
  8.5266 +    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
  8.5267 +    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
  8.5268 +    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
  8.5269 +    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
  8.5270 +} VkExternalMemoryFeatureFlagBitsNV;
  8.5271 +typedef VkFlags VkExternalMemoryFeatureFlagsNV;
  8.5272 +
  8.5273 +typedef struct VkExternalImageFormatPropertiesNV {
  8.5274 +    VkImageFormatProperties              imageFormatProperties;
  8.5275 +    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
  8.5276 +    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
  8.5277 +    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
  8.5278 +} VkExternalImageFormatPropertiesNV;
  8.5279 +
  8.5280 +
  8.5281 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
  8.5282 +
  8.5283 +#ifndef VK_NO_PROTOTYPES
  8.5284 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
  8.5285 +    VkPhysicalDevice                            physicalDevice,
  8.5286 +    VkFormat                                    format,
  8.5287 +    VkImageType                                 type,
  8.5288 +    VkImageTiling                               tiling,
  8.5289 +    VkImageUsageFlags                           usage,
  8.5290 +    VkImageCreateFlags                          flags,
  8.5291 +    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
  8.5292 +    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
  8.5293 +#endif
  8.5294 +
  8.5295 +#define VK_NV_external_memory 1
  8.5296 +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
  8.5297 +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
  8.5298 +
  8.5299 +typedef struct VkExternalMemoryImageCreateInfoNV {
  8.5300 +    VkStructureType                      sType;
  8.5301 +    const void*                          pNext;
  8.5302 +    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
  8.5303 +} VkExternalMemoryImageCreateInfoNV;
  8.5304 +
  8.5305 +typedef struct VkExportMemoryAllocateInfoNV {
  8.5306 +    VkStructureType                      sType;
  8.5307 +    const void*                          pNext;
  8.5308 +    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
  8.5309 +} VkExportMemoryAllocateInfoNV;
  8.5310 +
  8.5311 +
  8.5312 +
  8.5313 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.5314 +#define VK_NV_external_memory_win32 1
  8.5315 +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
  8.5316 +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
  8.5317 +
  8.5318 +typedef struct VkImportMemoryWin32HandleInfoNV {
  8.5319 +    VkStructureType                      sType;
  8.5320 +    const void*                          pNext;
  8.5321 +    VkExternalMemoryHandleTypeFlagsNV    handleType;
  8.5322 +    HANDLE                               handle;
  8.5323 +} VkImportMemoryWin32HandleInfoNV;
  8.5324 +
  8.5325 +typedef struct VkExportMemoryWin32HandleInfoNV {
  8.5326 +    VkStructureType               sType;
  8.5327 +    const void*                   pNext;
  8.5328 +    const SECURITY_ATTRIBUTES*    pAttributes;
  8.5329 +    DWORD                         dwAccess;
  8.5330 +} VkExportMemoryWin32HandleInfoNV;
  8.5331 +
  8.5332 +
  8.5333 +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
  8.5334 +
  8.5335 +#ifndef VK_NO_PROTOTYPES
  8.5336 +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
  8.5337 +    VkDevice                                    device,
  8.5338 +    VkDeviceMemory                              memory,
  8.5339 +    VkExternalMemoryHandleTypeFlagsNV           handleType,
  8.5340 +    HANDLE*                                     pHandle);
  8.5341 +#endif
  8.5342 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.5343 +
  8.5344 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  8.5345 +#define VK_NV_win32_keyed_mutex 1
  8.5346 +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
  8.5347 +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
  8.5348 +
  8.5349 +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
  8.5350 +    VkStructureType          sType;
  8.5351 +    const void*              pNext;
  8.5352 +    uint32_t                 acquireCount;
  8.5353 +    const VkDeviceMemory*    pAcquireSyncs;
  8.5354 +    const uint64_t*          pAcquireKeys;
  8.5355 +    const uint32_t*          pAcquireTimeoutMilliseconds;
  8.5356 +    uint32_t                 releaseCount;
  8.5357 +    const VkDeviceMemory*    pReleaseSyncs;
  8.5358 +    const uint64_t*          pReleaseKeys;
  8.5359 +} VkWin32KeyedMutexAcquireReleaseInfoNV;
  8.5360 +
  8.5361 +
  8.5362 +#endif /* VK_USE_PLATFORM_WIN32_KHR */
  8.5363 +
  8.5364 +#define VK_KHX_device_group 1
  8.5365 +#define VK_MAX_DEVICE_GROUP_SIZE_KHX      32
  8.5366 +#define VK_KHX_DEVICE_GROUP_SPEC_VERSION  1
  8.5367 +#define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group"
  8.5368 +
  8.5369 +
  8.5370 +typedef enum VkPeerMemoryFeatureFlagBitsKHX {
  8.5371 +    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001,
  8.5372 +    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002,
  8.5373 +    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004,
  8.5374 +    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008,
  8.5375 +    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
  8.5376 +} VkPeerMemoryFeatureFlagBitsKHX;
  8.5377 +typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
  8.5378 +
  8.5379 +typedef enum VkMemoryAllocateFlagBitsKHX {
  8.5380 +    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001,
  8.5381 +    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
  8.5382 +} VkMemoryAllocateFlagBitsKHX;
  8.5383 +typedef VkFlags VkMemoryAllocateFlagsKHX;
  8.5384 +
  8.5385 +typedef enum VkDeviceGroupPresentModeFlagBitsKHX {
  8.5386 +    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001,
  8.5387 +    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002,
  8.5388 +    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004,
  8.5389 +    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008,
  8.5390 +    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
  8.5391 +} VkDeviceGroupPresentModeFlagBitsKHX;
  8.5392 +typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
  8.5393 +
  8.5394 +typedef struct VkMemoryAllocateFlagsInfoKHX {
  8.5395 +    VkStructureType             sType;
  8.5396 +    const void*                 pNext;
  8.5397 +    VkMemoryAllocateFlagsKHX    flags;
  8.5398 +    uint32_t                    deviceMask;
  8.5399 +} VkMemoryAllocateFlagsInfoKHX;
  8.5400 +
  8.5401 +typedef struct VkBindBufferMemoryInfoKHX {
  8.5402 +    VkStructureType    sType;
  8.5403 +    const void*        pNext;
  8.5404 +    VkBuffer           buffer;
  8.5405 +    VkDeviceMemory     memory;
  8.5406 +    VkDeviceSize       memoryOffset;
  8.5407 +    uint32_t           deviceIndexCount;
  8.5408 +    const uint32_t*    pDeviceIndices;
  8.5409 +} VkBindBufferMemoryInfoKHX;
  8.5410 +
  8.5411 +typedef struct VkBindImageMemoryInfoKHX {
  8.5412 +    VkStructureType    sType;
  8.5413 +    const void*        pNext;
  8.5414 +    VkImage            image;
  8.5415 +    VkDeviceMemory     memory;
  8.5416 +    VkDeviceSize       memoryOffset;
  8.5417 +    uint32_t           deviceIndexCount;
  8.5418 +    const uint32_t*    pDeviceIndices;
  8.5419 +    uint32_t           SFRRectCount;
  8.5420 +    const VkRect2D*    pSFRRects;
  8.5421 +} VkBindImageMemoryInfoKHX;
  8.5422 +
  8.5423 +typedef struct VkDeviceGroupRenderPassBeginInfoKHX {
  8.5424 +    VkStructureType    sType;
  8.5425 +    const void*        pNext;
  8.5426 +    uint32_t           deviceMask;
  8.5427 +    uint32_t           deviceRenderAreaCount;
  8.5428 +    const VkRect2D*    pDeviceRenderAreas;
  8.5429 +} VkDeviceGroupRenderPassBeginInfoKHX;
  8.5430 +
  8.5431 +typedef struct VkDeviceGroupCommandBufferBeginInfoKHX {
  8.5432 +    VkStructureType    sType;
  8.5433 +    const void*        pNext;
  8.5434 +    uint32_t           deviceMask;
  8.5435 +} VkDeviceGroupCommandBufferBeginInfoKHX;
  8.5436 +
  8.5437 +typedef struct VkDeviceGroupSubmitInfoKHX {
  8.5438 +    VkStructureType    sType;
  8.5439 +    const void*        pNext;
  8.5440 +    uint32_t           waitSemaphoreCount;
  8.5441 +    const uint32_t*    pWaitSemaphoreDeviceIndices;
  8.5442 +    uint32_t           commandBufferCount;
  8.5443 +    const uint32_t*    pCommandBufferDeviceMasks;
  8.5444 +    uint32_t           signalSemaphoreCount;
  8.5445 +    const uint32_t*    pSignalSemaphoreDeviceIndices;
  8.5446 +} VkDeviceGroupSubmitInfoKHX;
  8.5447 +
  8.5448 +typedef struct VkDeviceGroupBindSparseInfoKHX {
  8.5449 +    VkStructureType    sType;
  8.5450 +    const void*        pNext;
  8.5451 +    uint32_t           resourceDeviceIndex;
  8.5452 +    uint32_t           memoryDeviceIndex;
  8.5453 +} VkDeviceGroupBindSparseInfoKHX;
  8.5454 +
  8.5455 +typedef struct VkDeviceGroupPresentCapabilitiesKHX {
  8.5456 +    VkStructureType                     sType;
  8.5457 +    const void*                         pNext;
  8.5458 +    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
  8.5459 +    VkDeviceGroupPresentModeFlagsKHX    modes;
  8.5460 +} VkDeviceGroupPresentCapabilitiesKHX;
  8.5461 +
  8.5462 +typedef struct VkImageSwapchainCreateInfoKHX {
  8.5463 +    VkStructureType    sType;
  8.5464 +    const void*        pNext;
  8.5465 +    VkSwapchainKHR     swapchain;
  8.5466 +} VkImageSwapchainCreateInfoKHX;
  8.5467 +
  8.5468 +typedef struct VkBindImageMemorySwapchainInfoKHX {
  8.5469 +    VkStructureType    sType;
  8.5470 +    const void*        pNext;
  8.5471 +    VkSwapchainKHR     swapchain;
  8.5472 +    uint32_t           imageIndex;
  8.5473 +} VkBindImageMemorySwapchainInfoKHX;
  8.5474 +
  8.5475 +typedef struct VkAcquireNextImageInfoKHX {
  8.5476 +    VkStructureType    sType;
  8.5477 +    const void*        pNext;
  8.5478 +    VkSwapchainKHR     swapchain;
  8.5479 +    uint64_t           timeout;
  8.5480 +    VkSemaphore        semaphore;
  8.5481 +    VkFence            fence;
  8.5482 +    uint32_t           deviceMask;
  8.5483 +} VkAcquireNextImageInfoKHX;
  8.5484 +
  8.5485 +typedef struct VkDeviceGroupPresentInfoKHX {
  8.5486 +    VkStructureType                        sType;
  8.5487 +    const void*                            pNext;
  8.5488 +    uint32_t                               swapchainCount;
  8.5489 +    const uint32_t*                        pDeviceMasks;
  8.5490 +    VkDeviceGroupPresentModeFlagBitsKHX    mode;
  8.5491 +} VkDeviceGroupPresentInfoKHX;
  8.5492 +
  8.5493 +typedef struct VkDeviceGroupSwapchainCreateInfoKHX {
  8.5494 +    VkStructureType                     sType;
  8.5495 +    const void*                         pNext;
  8.5496 +    VkDeviceGroupPresentModeFlagsKHX    modes;
  8.5497 +} VkDeviceGroupSwapchainCreateInfoKHX;
  8.5498 +
  8.5499 +
  8.5500 +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures);
  8.5501 +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHX* pBindInfos);
  8.5502 +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHX* pBindInfos);
  8.5503 +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
  8.5504 +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities);
  8.5505 +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes);
  8.5506 +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex);
  8.5507 +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHX)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
  8.5508 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
  8.5509 +
  8.5510 +#ifndef VK_NO_PROTOTYPES
  8.5511 +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX(
  8.5512 +    VkDevice                                    device,
  8.5513 +    uint32_t                                    heapIndex,
  8.5514 +    uint32_t                                    localDeviceIndex,
  8.5515 +    uint32_t                                    remoteDeviceIndex,
  8.5516 +    VkPeerMemoryFeatureFlagsKHX*                pPeerMemoryFeatures);
  8.5517 +
  8.5518 +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHX(
  8.5519 +    VkDevice                                    device,
  8.5520 +    uint32_t                                    bindInfoCount,
  8.5521 +    const VkBindBufferMemoryInfoKHX*            pBindInfos);
  8.5522 +
  8.5523 +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHX(
  8.5524 +    VkDevice                                    device,
  8.5525 +    uint32_t                                    bindInfoCount,
  8.5526 +    const VkBindImageMemoryInfoKHX*             pBindInfos);
  8.5527 +
  8.5528 +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX(
  8.5529 +    VkCommandBuffer                             commandBuffer,
  8.5530 +    uint32_t                                    deviceMask);
  8.5531 +
  8.5532 +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX(
  8.5533 +    VkDevice                                    device,
  8.5534 +    VkDeviceGroupPresentCapabilitiesKHX*        pDeviceGroupPresentCapabilities);
  8.5535 +
  8.5536 +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX(
  8.5537 +    VkDevice                                    device,
  8.5538 +    VkSurfaceKHR                                surface,
  8.5539 +    VkDeviceGroupPresentModeFlagsKHX*           pModes);
  8.5540 +
  8.5541 +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX(
  8.5542 +    VkDevice                                    device,
  8.5543 +    const VkAcquireNextImageInfoKHX*            pAcquireInfo,
  8.5544 +    uint32_t*                                   pImageIndex);
  8.5545 +
  8.5546 +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX(
  8.5547 +    VkCommandBuffer                             commandBuffer,
  8.5548 +    uint32_t                                    baseGroupX,
  8.5549 +    uint32_t                                    baseGroupY,
  8.5550 +    uint32_t                                    baseGroupZ,
  8.5551 +    uint32_t                                    groupCountX,
  8.5552 +    uint32_t                                    groupCountY,
  8.5553 +    uint32_t                                    groupCountZ);
  8.5554 +
  8.5555 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX(
  8.5556 +    VkPhysicalDevice                            physicalDevice,
  8.5557 +    VkSurfaceKHR                                surface,
  8.5558 +    uint32_t*                                   pRectCount,
  8.5559 +    VkRect2D*                                   pRects);
  8.5560 +#endif
  8.5561 +
  8.5562 +#define VK_EXT_validation_flags 1
  8.5563 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
  8.5564 +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
  8.5565 +
  8.5566 +
  8.5567 +typedef enum VkValidationCheckEXT {
  8.5568 +    VK_VALIDATION_CHECK_ALL_EXT = 0,
  8.5569 +    VK_VALIDATION_CHECK_SHADERS_EXT = 1,
  8.5570 +    VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
  8.5571 +    VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT,
  8.5572 +    VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
  8.5573 +    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
  8.5574 +} VkValidationCheckEXT;
  8.5575 +
  8.5576 +typedef struct VkValidationFlagsEXT {
  8.5577 +    VkStructureType          sType;
  8.5578 +    const void*              pNext;
  8.5579 +    uint32_t                 disabledValidationCheckCount;
  8.5580 +    VkValidationCheckEXT*    pDisabledValidationChecks;
  8.5581 +} VkValidationFlagsEXT;
  8.5582 +
  8.5583 +
  8.5584 +
  8.5585 +#ifdef VK_USE_PLATFORM_VI_NN
  8.5586 +#define VK_NN_vi_surface 1
  8.5587 +#define VK_NN_VI_SURFACE_SPEC_VERSION     1
  8.5588 +#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
  8.5589 +
  8.5590 +typedef VkFlags VkViSurfaceCreateFlagsNN;
  8.5591 +
  8.5592 +typedef struct VkViSurfaceCreateInfoNN {
  8.5593 +    VkStructureType             sType;
  8.5594 +    const void*                 pNext;
  8.5595 +    VkViSurfaceCreateFlagsNN    flags;
  8.5596 +    void*                       window;
  8.5597 +} VkViSurfaceCreateInfoNN;
  8.5598 +
  8.5599 +
  8.5600 +typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.5601 +
  8.5602 +#ifndef VK_NO_PROTOTYPES
  8.5603 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
  8.5604 +    VkInstance                                  instance,
  8.5605 +    const VkViSurfaceCreateInfoNN*              pCreateInfo,
  8.5606 +    const VkAllocationCallbacks*                pAllocator,
  8.5607 +    VkSurfaceKHR*                               pSurface);
  8.5608 +#endif
  8.5609 +#endif /* VK_USE_PLATFORM_VI_NN */
  8.5610 +
  8.5611 +#define VK_EXT_shader_subgroup_ballot 1
  8.5612 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
  8.5613 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
  8.5614 +
  8.5615 +
  8.5616 +#define VK_EXT_shader_subgroup_vote 1
  8.5617 +#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
  8.5618 +#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
  8.5619 +
  8.5620 +
  8.5621 +#define VK_KHX_device_group_creation 1
  8.5622 +#define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1
  8.5623 +#define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation"
  8.5624 +
  8.5625 +typedef struct VkPhysicalDeviceGroupPropertiesKHX {
  8.5626 +    VkStructureType     sType;
  8.5627 +    void*               pNext;
  8.5628 +    uint32_t            physicalDeviceCount;
  8.5629 +    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
  8.5630 +    VkBool32            subsetAllocation;
  8.5631 +} VkPhysicalDeviceGroupPropertiesKHX;
  8.5632 +
  8.5633 +typedef struct VkDeviceGroupDeviceCreateInfoKHX {
  8.5634 +    VkStructureType            sType;
  8.5635 +    const void*                pNext;
  8.5636 +    uint32_t                   physicalDeviceCount;
  8.5637 +    const VkPhysicalDevice*    pPhysicalDevices;
  8.5638 +} VkDeviceGroupDeviceCreateInfoKHX;
  8.5639 +
  8.5640 +
  8.5641 +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties);
  8.5642 +
  8.5643 +#ifndef VK_NO_PROTOTYPES
  8.5644 +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX(
  8.5645 +    VkInstance                                  instance,
  8.5646 +    uint32_t*                                   pPhysicalDeviceGroupCount,
  8.5647 +    VkPhysicalDeviceGroupPropertiesKHX*         pPhysicalDeviceGroupProperties);
  8.5648 +#endif
  8.5649 +
  8.5650 +#define VK_NVX_device_generated_commands 1
  8.5651 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
  8.5652 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
  8.5653 +
  8.5654 +#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
  8.5655 +#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
  8.5656 +
  8.5657 +
  8.5658 +typedef enum VkIndirectCommandsTokenTypeNVX {
  8.5659 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
  8.5660 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
  8.5661 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
  8.5662 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
  8.5663 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
  8.5664 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
  8.5665 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
  8.5666 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
  8.5667 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
  8.5668 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX,
  8.5669 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1),
  8.5670 +    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
  8.5671 +} VkIndirectCommandsTokenTypeNVX;
  8.5672 +
  8.5673 +typedef enum VkObjectEntryTypeNVX {
  8.5674 +    VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
  8.5675 +    VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
  8.5676 +    VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
  8.5677 +    VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
  8.5678 +    VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
  8.5679 +    VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
  8.5680 +    VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX,
  8.5681 +    VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1),
  8.5682 +    VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
  8.5683 +} VkObjectEntryTypeNVX;
  8.5684 +
  8.5685 +
  8.5686 +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
  8.5687 +    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
  8.5688 +    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
  8.5689 +    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
  8.5690 +    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
  8.5691 +    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
  8.5692 +} VkIndirectCommandsLayoutUsageFlagBitsNVX;
  8.5693 +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
  8.5694 +
  8.5695 +typedef enum VkObjectEntryUsageFlagBitsNVX {
  8.5696 +    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
  8.5697 +    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
  8.5698 +    VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
  8.5699 +} VkObjectEntryUsageFlagBitsNVX;
  8.5700 +typedef VkFlags VkObjectEntryUsageFlagsNVX;
  8.5701 +
  8.5702 +typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
  8.5703 +    VkStructureType    sType;
  8.5704 +    const void*        pNext;
  8.5705 +    VkBool32           computeBindingPointSupport;
  8.5706 +} VkDeviceGeneratedCommandsFeaturesNVX;
  8.5707 +
  8.5708 +typedef struct VkDeviceGeneratedCommandsLimitsNVX {
  8.5709 +    VkStructureType    sType;
  8.5710 +    const void*        pNext;
  8.5711 +    uint32_t           maxIndirectCommandsLayoutTokenCount;
  8.5712 +    uint32_t           maxObjectEntryCounts;
  8.5713 +    uint32_t           minSequenceCountBufferOffsetAlignment;
  8.5714 +    uint32_t           minSequenceIndexBufferOffsetAlignment;
  8.5715 +    uint32_t           minCommandsTokenBufferOffsetAlignment;
  8.5716 +} VkDeviceGeneratedCommandsLimitsNVX;
  8.5717 +
  8.5718 +typedef struct VkIndirectCommandsTokenNVX {
  8.5719 +    VkIndirectCommandsTokenTypeNVX    tokenType;
  8.5720 +    VkBuffer                          buffer;
  8.5721 +    VkDeviceSize                      offset;
  8.5722 +} VkIndirectCommandsTokenNVX;
  8.5723 +
  8.5724 +typedef struct VkIndirectCommandsLayoutTokenNVX {
  8.5725 +    VkIndirectCommandsTokenTypeNVX    tokenType;
  8.5726 +    uint32_t                          bindingUnit;
  8.5727 +    uint32_t                          dynamicCount;
  8.5728 +    uint32_t                          divisor;
  8.5729 +} VkIndirectCommandsLayoutTokenNVX;
  8.5730 +
  8.5731 +typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
  8.5732 +    VkStructureType                            sType;
  8.5733 +    const void*                                pNext;
  8.5734 +    VkPipelineBindPoint                        pipelineBindPoint;
  8.5735 +    VkIndirectCommandsLayoutUsageFlagsNVX      flags;
  8.5736 +    uint32_t                                   tokenCount;
  8.5737 +    const VkIndirectCommandsLayoutTokenNVX*    pTokens;
  8.5738 +} VkIndirectCommandsLayoutCreateInfoNVX;
  8.5739 +
  8.5740 +typedef struct VkCmdProcessCommandsInfoNVX {
  8.5741 +    VkStructureType                      sType;
  8.5742 +    const void*                          pNext;
  8.5743 +    VkObjectTableNVX                     objectTable;
  8.5744 +    VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
  8.5745 +    uint32_t                             indirectCommandsTokenCount;
  8.5746 +    const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
  8.5747 +    uint32_t                             maxSequencesCount;
  8.5748 +    VkCommandBuffer                      targetCommandBuffer;
  8.5749 +    VkBuffer                             sequencesCountBuffer;
  8.5750 +    VkDeviceSize                         sequencesCountOffset;
  8.5751 +    VkBuffer                             sequencesIndexBuffer;
  8.5752 +    VkDeviceSize                         sequencesIndexOffset;
  8.5753 +} VkCmdProcessCommandsInfoNVX;
  8.5754 +
  8.5755 +typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
  8.5756 +    VkStructureType                sType;
  8.5757 +    const void*                    pNext;
  8.5758 +    VkObjectTableNVX               objectTable;
  8.5759 +    VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
  8.5760 +    uint32_t                       maxSequencesCount;
  8.5761 +} VkCmdReserveSpaceForCommandsInfoNVX;
  8.5762 +
  8.5763 +typedef struct VkObjectTableCreateInfoNVX {
  8.5764 +    VkStructureType                      sType;
  8.5765 +    const void*                          pNext;
  8.5766 +    uint32_t                             objectCount;
  8.5767 +    const VkObjectEntryTypeNVX*          pObjectEntryTypes;
  8.5768 +    const uint32_t*                      pObjectEntryCounts;
  8.5769 +    const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
  8.5770 +    uint32_t                             maxUniformBuffersPerDescriptor;
  8.5771 +    uint32_t                             maxStorageBuffersPerDescriptor;
  8.5772 +    uint32_t                             maxStorageImagesPerDescriptor;
  8.5773 +    uint32_t                             maxSampledImagesPerDescriptor;
  8.5774 +    uint32_t                             maxPipelineLayouts;
  8.5775 +} VkObjectTableCreateInfoNVX;
  8.5776 +
  8.5777 +typedef struct VkObjectTableEntryNVX {
  8.5778 +    VkObjectEntryTypeNVX          type;
  8.5779 +    VkObjectEntryUsageFlagsNVX    flags;
  8.5780 +} VkObjectTableEntryNVX;
  8.5781 +
  8.5782 +typedef struct VkObjectTablePipelineEntryNVX {
  8.5783 +    VkObjectEntryTypeNVX          type;
  8.5784 +    VkObjectEntryUsageFlagsNVX    flags;
  8.5785 +    VkPipeline                    pipeline;
  8.5786 +} VkObjectTablePipelineEntryNVX;
  8.5787 +
  8.5788 +typedef struct VkObjectTableDescriptorSetEntryNVX {
  8.5789 +    VkObjectEntryTypeNVX          type;
  8.5790 +    VkObjectEntryUsageFlagsNVX    flags;
  8.5791 +    VkPipelineLayout              pipelineLayout;
  8.5792 +    VkDescriptorSet               descriptorSet;
  8.5793 +} VkObjectTableDescriptorSetEntryNVX;
  8.5794 +
  8.5795 +typedef struct VkObjectTableVertexBufferEntryNVX {
  8.5796 +    VkObjectEntryTypeNVX          type;
  8.5797 +    VkObjectEntryUsageFlagsNVX    flags;
  8.5798 +    VkBuffer                      buffer;
  8.5799 +} VkObjectTableVertexBufferEntryNVX;
  8.5800 +
  8.5801 +typedef struct VkObjectTableIndexBufferEntryNVX {
  8.5802 +    VkObjectEntryTypeNVX          type;
  8.5803 +    VkObjectEntryUsageFlagsNVX    flags;
  8.5804 +    VkBuffer                      buffer;
  8.5805 +    VkIndexType                   indexType;
  8.5806 +} VkObjectTableIndexBufferEntryNVX;
  8.5807 +
  8.5808 +typedef struct VkObjectTablePushConstantEntryNVX {
  8.5809 +    VkObjectEntryTypeNVX          type;
  8.5810 +    VkObjectEntryUsageFlagsNVX    flags;
  8.5811 +    VkPipelineLayout              pipelineLayout;
  8.5812 +    VkShaderStageFlags            stageFlags;
  8.5813 +} VkObjectTablePushConstantEntryNVX;
  8.5814 +
  8.5815 +
  8.5816 +typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
  8.5817 +typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
  8.5818 +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
  8.5819 +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
  8.5820 +typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
  8.5821 +typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
  8.5822 +typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
  8.5823 +typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
  8.5824 +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
  8.5825 +
  8.5826 +#ifndef VK_NO_PROTOTYPES
  8.5827 +VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
  8.5828 +    VkCommandBuffer                             commandBuffer,
  8.5829 +    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
  8.5830 +
  8.5831 +VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
  8.5832 +    VkCommandBuffer                             commandBuffer,
  8.5833 +    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
  8.5834 +
  8.5835 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
  8.5836 +    VkDevice                                    device,
  8.5837 +    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
  8.5838 +    const VkAllocationCallbacks*                pAllocator,
  8.5839 +    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
  8.5840 +
  8.5841 +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
  8.5842 +    VkDevice                                    device,
  8.5843 +    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
  8.5844 +    const VkAllocationCallbacks*                pAllocator);
  8.5845 +
  8.5846 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
  8.5847 +    VkDevice                                    device,
  8.5848 +    const VkObjectTableCreateInfoNVX*           pCreateInfo,
  8.5849 +    const VkAllocationCallbacks*                pAllocator,
  8.5850 +    VkObjectTableNVX*                           pObjectTable);
  8.5851 +
  8.5852 +VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
  8.5853 +    VkDevice                                    device,
  8.5854 +    VkObjectTableNVX                            objectTable,
  8.5855 +    const VkAllocationCallbacks*                pAllocator);
  8.5856 +
  8.5857 +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
  8.5858 +    VkDevice                                    device,
  8.5859 +    VkObjectTableNVX                            objectTable,
  8.5860 +    uint32_t                                    objectCount,
  8.5861 +    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
  8.5862 +    const uint32_t*                             pObjectIndices);
  8.5863 +
  8.5864 +VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
  8.5865 +    VkDevice                                    device,
  8.5866 +    VkObjectTableNVX                            objectTable,
  8.5867 +    uint32_t                                    objectCount,
  8.5868 +    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
  8.5869 +    const uint32_t*                             pObjectIndices);
  8.5870 +
  8.5871 +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
  8.5872 +    VkPhysicalDevice                            physicalDevice,
  8.5873 +    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
  8.5874 +    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
  8.5875 +#endif
  8.5876 +
  8.5877 +#define VK_NV_clip_space_w_scaling 1
  8.5878 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
  8.5879 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
  8.5880 +
  8.5881 +typedef struct VkViewportWScalingNV {
  8.5882 +    float    xcoeff;
  8.5883 +    float    ycoeff;
  8.5884 +} VkViewportWScalingNV;
  8.5885 +
  8.5886 +typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
  8.5887 +    VkStructureType                sType;
  8.5888 +    const void*                    pNext;
  8.5889 +    VkBool32                       viewportWScalingEnable;
  8.5890 +    uint32_t                       viewportCount;
  8.5891 +    const VkViewportWScalingNV*    pViewportWScalings;
  8.5892 +} VkPipelineViewportWScalingStateCreateInfoNV;
  8.5893 +
  8.5894 +
  8.5895 +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
  8.5896 +
  8.5897 +#ifndef VK_NO_PROTOTYPES
  8.5898 +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
  8.5899 +    VkCommandBuffer                             commandBuffer,
  8.5900 +    uint32_t                                    firstViewport,
  8.5901 +    uint32_t                                    viewportCount,
  8.5902 +    const VkViewportWScalingNV*                 pViewportWScalings);
  8.5903 +#endif
  8.5904 +
  8.5905 +#define VK_EXT_direct_mode_display 1
  8.5906 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
  8.5907 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
  8.5908 +
  8.5909 +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
  8.5910 +
  8.5911 +#ifndef VK_NO_PROTOTYPES
  8.5912 +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
  8.5913 +    VkPhysicalDevice                            physicalDevice,
  8.5914 +    VkDisplayKHR                                display);
  8.5915 +#endif
  8.5916 +
  8.5917 +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
  8.5918 +#define VK_EXT_acquire_xlib_display 1
  8.5919 +#include <X11/extensions/Xrandr.h>
  8.5920 +
  8.5921 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
  8.5922 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
  8.5923 +
  8.5924 +typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
  8.5925 +typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
  8.5926 +
  8.5927 +#ifndef VK_NO_PROTOTYPES
  8.5928 +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
  8.5929 +    VkPhysicalDevice                            physicalDevice,
  8.5930 +    Display*                                    dpy,
  8.5931 +    VkDisplayKHR                                display);
  8.5932 +
  8.5933 +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
  8.5934 +    VkPhysicalDevice                            physicalDevice,
  8.5935 +    Display*                                    dpy,
  8.5936 +    RROutput                                    rrOutput,
  8.5937 +    VkDisplayKHR*                               pDisplay);
  8.5938 +#endif
  8.5939 +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
  8.5940 +
  8.5941 +#define VK_EXT_display_surface_counter 1
  8.5942 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
  8.5943 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
  8.5944 +#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
  8.5945 +
  8.5946 +
  8.5947 +typedef enum VkSurfaceCounterFlagBitsEXT {
  8.5948 +    VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
  8.5949 +    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
  8.5950 +} VkSurfaceCounterFlagBitsEXT;
  8.5951 +typedef VkFlags VkSurfaceCounterFlagsEXT;
  8.5952 +
  8.5953 +typedef struct VkSurfaceCapabilities2EXT {
  8.5954 +    VkStructureType                  sType;
  8.5955 +    void*                            pNext;
  8.5956 +    uint32_t                         minImageCount;
  8.5957 +    uint32_t                         maxImageCount;
  8.5958 +    VkExtent2D                       currentExtent;
  8.5959 +    VkExtent2D                       minImageExtent;
  8.5960 +    VkExtent2D                       maxImageExtent;
  8.5961 +    uint32_t                         maxImageArrayLayers;
  8.5962 +    VkSurfaceTransformFlagsKHR       supportedTransforms;
  8.5963 +    VkSurfaceTransformFlagBitsKHR    currentTransform;
  8.5964 +    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
  8.5965 +    VkImageUsageFlags                supportedUsageFlags;
  8.5966 +    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
  8.5967 +} VkSurfaceCapabilities2EXT;
  8.5968 +
  8.5969 +
  8.5970 +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
  8.5971 +
  8.5972 +#ifndef VK_NO_PROTOTYPES
  8.5973 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
  8.5974 +    VkPhysicalDevice                            physicalDevice,
  8.5975 +    VkSurfaceKHR                                surface,
  8.5976 +    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
  8.5977 +#endif
  8.5978 +
  8.5979 +#define VK_EXT_display_control 1
  8.5980 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
  8.5981 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
  8.5982 +
  8.5983 +
  8.5984 +typedef enum VkDisplayPowerStateEXT {
  8.5985 +    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
  8.5986 +    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
  8.5987 +    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
  8.5988 +    VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
  8.5989 +    VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
  8.5990 +    VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
  8.5991 +    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
  8.5992 +} VkDisplayPowerStateEXT;
  8.5993 +
  8.5994 +typedef enum VkDeviceEventTypeEXT {
  8.5995 +    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
  8.5996 +    VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
  8.5997 +    VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
  8.5998 +    VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
  8.5999 +    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
  8.6000 +} VkDeviceEventTypeEXT;
  8.6001 +
  8.6002 +typedef enum VkDisplayEventTypeEXT {
  8.6003 +    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
  8.6004 +    VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
  8.6005 +    VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
  8.6006 +    VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
  8.6007 +    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
  8.6008 +} VkDisplayEventTypeEXT;
  8.6009 +
  8.6010 +typedef struct VkDisplayPowerInfoEXT {
  8.6011 +    VkStructureType           sType;
  8.6012 +    const void*               pNext;
  8.6013 +    VkDisplayPowerStateEXT    powerState;
  8.6014 +} VkDisplayPowerInfoEXT;
  8.6015 +
  8.6016 +typedef struct VkDeviceEventInfoEXT {
  8.6017 +    VkStructureType         sType;
  8.6018 +    const void*             pNext;
  8.6019 +    VkDeviceEventTypeEXT    deviceEvent;
  8.6020 +} VkDeviceEventInfoEXT;
  8.6021 +
  8.6022 +typedef struct VkDisplayEventInfoEXT {
  8.6023 +    VkStructureType          sType;
  8.6024 +    const void*              pNext;
  8.6025 +    VkDisplayEventTypeEXT    displayEvent;
  8.6026 +} VkDisplayEventInfoEXT;
  8.6027 +
  8.6028 +typedef struct VkSwapchainCounterCreateInfoEXT {
  8.6029 +    VkStructureType             sType;
  8.6030 +    const void*                 pNext;
  8.6031 +    VkSurfaceCounterFlagsEXT    surfaceCounters;
  8.6032 +} VkSwapchainCounterCreateInfoEXT;
  8.6033 +
  8.6034 +
  8.6035 +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
  8.6036 +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  8.6037 +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  8.6038 +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
  8.6039 +
  8.6040 +#ifndef VK_NO_PROTOTYPES
  8.6041 +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
  8.6042 +    VkDevice                                    device,
  8.6043 +    VkDisplayKHR                                display,
  8.6044 +    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
  8.6045 +
  8.6046 +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
  8.6047 +    VkDevice                                    device,
  8.6048 +    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
  8.6049 +    const VkAllocationCallbacks*                pAllocator,
  8.6050 +    VkFence*                                    pFence);
  8.6051 +
  8.6052 +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
  8.6053 +    VkDevice                                    device,
  8.6054 +    VkDisplayKHR                                display,
  8.6055 +    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
  8.6056 +    const VkAllocationCallbacks*                pAllocator,
  8.6057 +    VkFence*                                    pFence);
  8.6058 +
  8.6059 +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
  8.6060 +    VkDevice                                    device,
  8.6061 +    VkSwapchainKHR                              swapchain,
  8.6062 +    VkSurfaceCounterFlagBitsEXT                 counter,
  8.6063 +    uint64_t*                                   pCounterValue);
  8.6064 +#endif
  8.6065 +
  8.6066 +#define VK_GOOGLE_display_timing 1
  8.6067 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
  8.6068 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
  8.6069 +
  8.6070 +typedef struct VkRefreshCycleDurationGOOGLE {
  8.6071 +    uint64_t    refreshDuration;
  8.6072 +} VkRefreshCycleDurationGOOGLE;
  8.6073 +
  8.6074 +typedef struct VkPastPresentationTimingGOOGLE {
  8.6075 +    uint32_t    presentID;
  8.6076 +    uint64_t    desiredPresentTime;
  8.6077 +    uint64_t    actualPresentTime;
  8.6078 +    uint64_t    earliestPresentTime;
  8.6079 +    uint64_t    presentMargin;
  8.6080 +} VkPastPresentationTimingGOOGLE;
  8.6081 +
  8.6082 +typedef struct VkPresentTimeGOOGLE {
  8.6083 +    uint32_t    presentID;
  8.6084 +    uint64_t    desiredPresentTime;
  8.6085 +} VkPresentTimeGOOGLE;
  8.6086 +
  8.6087 +typedef struct VkPresentTimesInfoGOOGLE {
  8.6088 +    VkStructureType               sType;
  8.6089 +    const void*                   pNext;
  8.6090 +    uint32_t                      swapchainCount;
  8.6091 +    const VkPresentTimeGOOGLE*    pTimes;
  8.6092 +} VkPresentTimesInfoGOOGLE;
  8.6093 +
  8.6094 +
  8.6095 +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
  8.6096 +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
  8.6097 +
  8.6098 +#ifndef VK_NO_PROTOTYPES
  8.6099 +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
  8.6100 +    VkDevice                                    device,
  8.6101 +    VkSwapchainKHR                              swapchain,
  8.6102 +    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
  8.6103 +
  8.6104 +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
  8.6105 +    VkDevice                                    device,
  8.6106 +    VkSwapchainKHR                              swapchain,
  8.6107 +    uint32_t*                                   pPresentationTimingCount,
  8.6108 +    VkPastPresentationTimingGOOGLE*             pPresentationTimings);
  8.6109 +#endif
  8.6110 +
  8.6111 +#define VK_NV_sample_mask_override_coverage 1
  8.6112 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
  8.6113 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
  8.6114 +
  8.6115 +
  8.6116 +#define VK_NV_geometry_shader_passthrough 1
  8.6117 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
  8.6118 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
  8.6119 +
  8.6120 +
  8.6121 +#define VK_NV_viewport_array2 1
  8.6122 +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
  8.6123 +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
  8.6124 +
  8.6125 +
  8.6126 +#define VK_NVX_multiview_per_view_attributes 1
  8.6127 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
  8.6128 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
  8.6129 +
  8.6130 +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
  8.6131 +    VkStructureType    sType;
  8.6132 +    void*              pNext;
  8.6133 +    VkBool32           perViewPositionAllComponents;
  8.6134 +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
  8.6135 +
  8.6136 +
  8.6137 +
  8.6138 +#define VK_NV_viewport_swizzle 1
  8.6139 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
  8.6140 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
  8.6141 +
  8.6142 +
  8.6143 +typedef enum VkViewportCoordinateSwizzleNV {
  8.6144 +    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
  8.6145 +    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
  8.6146 +    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
  8.6147 +    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
  8.6148 +    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
  8.6149 +    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
  8.6150 +    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
  8.6151 +    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
  8.6152 +    VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
  8.6153 +    VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
  8.6154 +    VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
  8.6155 +    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
  8.6156 +} VkViewportCoordinateSwizzleNV;
  8.6157 +
  8.6158 +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
  8.6159 +
  8.6160 +typedef struct VkViewportSwizzleNV {
  8.6161 +    VkViewportCoordinateSwizzleNV    x;
  8.6162 +    VkViewportCoordinateSwizzleNV    y;
  8.6163 +    VkViewportCoordinateSwizzleNV    z;
  8.6164 +    VkViewportCoordinateSwizzleNV    w;
  8.6165 +} VkViewportSwizzleNV;
  8.6166 +
  8.6167 +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
  8.6168 +    VkStructureType                                sType;
  8.6169 +    const void*                                    pNext;
  8.6170 +    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
  8.6171 +    uint32_t                                       viewportCount;
  8.6172 +    const VkViewportSwizzleNV*                     pViewportSwizzles;
  8.6173 +} VkPipelineViewportSwizzleStateCreateInfoNV;
  8.6174 +
  8.6175 +
  8.6176 +
  8.6177 +#define VK_EXT_discard_rectangles 1
  8.6178 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
  8.6179 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
  8.6180 +
  8.6181 +
  8.6182 +typedef enum VkDiscardRectangleModeEXT {
  8.6183 +    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
  8.6184 +    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
  8.6185 +    VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
  8.6186 +    VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
  8.6187 +    VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
  8.6188 +    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
  8.6189 +} VkDiscardRectangleModeEXT;
  8.6190 +
  8.6191 +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
  8.6192 +
  8.6193 +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
  8.6194 +    VkStructureType    sType;
  8.6195 +    void*              pNext;
  8.6196 +    uint32_t           maxDiscardRectangles;
  8.6197 +} VkPhysicalDeviceDiscardRectanglePropertiesEXT;
  8.6198 +
  8.6199 +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
  8.6200 +    VkStructureType                                  sType;
  8.6201 +    const void*                                      pNext;
  8.6202 +    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
  8.6203 +    VkDiscardRectangleModeEXT                        discardRectangleMode;
  8.6204 +    uint32_t                                         discardRectangleCount;
  8.6205 +    const VkRect2D*                                  pDiscardRectangles;
  8.6206 +} VkPipelineDiscardRectangleStateCreateInfoEXT;
  8.6207 +
  8.6208 +
  8.6209 +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
  8.6210 +
  8.6211 +#ifndef VK_NO_PROTOTYPES
  8.6212 +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
  8.6213 +    VkCommandBuffer                             commandBuffer,
  8.6214 +    uint32_t                                    firstDiscardRectangle,
  8.6215 +    uint32_t                                    discardRectangleCount,
  8.6216 +    const VkRect2D*                             pDiscardRectangles);
  8.6217 +#endif
  8.6218 +
  8.6219 +#define VK_EXT_swapchain_colorspace 1
  8.6220 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3
  8.6221 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
  8.6222 +
  8.6223 +
  8.6224 +#define VK_EXT_hdr_metadata 1
  8.6225 +#define VK_EXT_HDR_METADATA_SPEC_VERSION  1
  8.6226 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
  8.6227 +
  8.6228 +typedef struct VkXYColorEXT {
  8.6229 +    float    x;
  8.6230 +    float    y;
  8.6231 +} VkXYColorEXT;
  8.6232 +
  8.6233 +typedef struct VkHdrMetadataEXT {
  8.6234 +    VkStructureType    sType;
  8.6235 +    const void*        pNext;
  8.6236 +    VkXYColorEXT       displayPrimaryRed;
  8.6237 +    VkXYColorEXT       displayPrimaryGreen;
  8.6238 +    VkXYColorEXT       displayPrimaryBlue;
  8.6239 +    VkXYColorEXT       whitePoint;
  8.6240 +    float              maxLuminance;
  8.6241 +    float              minLuminance;
  8.6242 +    float              maxContentLightLevel;
  8.6243 +    float              maxFrameAverageLightLevel;
  8.6244 +} VkHdrMetadataEXT;
  8.6245 +
  8.6246 +
  8.6247 +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
  8.6248 +
  8.6249 +#ifndef VK_NO_PROTOTYPES
  8.6250 +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
  8.6251 +    VkDevice                                    device,
  8.6252 +    uint32_t                                    swapchainCount,
  8.6253 +    const VkSwapchainKHR*                       pSwapchains,
  8.6254 +    const VkHdrMetadataEXT*                     pMetadata);
  8.6255 +#endif
  8.6256 +
  8.6257 +#ifdef VK_USE_PLATFORM_IOS_MVK
  8.6258 +#define VK_MVK_ios_surface 1
  8.6259 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
  8.6260 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
  8.6261 +
  8.6262 +typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
  8.6263 +
  8.6264 +typedef struct VkIOSSurfaceCreateInfoMVK {
  8.6265 +    VkStructureType               sType;
  8.6266 +    const void*                   pNext;
  8.6267 +    VkIOSSurfaceCreateFlagsMVK    flags;
  8.6268 +    const void*                   pView;
  8.6269 +} VkIOSSurfaceCreateInfoMVK;
  8.6270 +
  8.6271 +
  8.6272 +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.6273 +
  8.6274 +#ifndef VK_NO_PROTOTYPES
  8.6275 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
  8.6276 +    VkInstance                                  instance,
  8.6277 +    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
  8.6278 +    const VkAllocationCallbacks*                pAllocator,
  8.6279 +    VkSurfaceKHR*                               pSurface);
  8.6280 +#endif
  8.6281 +#endif /* VK_USE_PLATFORM_IOS_MVK */
  8.6282 +
  8.6283 +#ifdef VK_USE_PLATFORM_MACOS_MVK
  8.6284 +#define VK_MVK_macos_surface 1
  8.6285 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
  8.6286 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
  8.6287 +
  8.6288 +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
  8.6289 +
  8.6290 +typedef struct VkMacOSSurfaceCreateInfoMVK {
  8.6291 +    VkStructureType                 sType;
  8.6292 +    const void*                     pNext;
  8.6293 +    VkMacOSSurfaceCreateFlagsMVK    flags;
  8.6294 +    const void*                     pView;
  8.6295 +} VkMacOSSurfaceCreateInfoMVK;
  8.6296 +
  8.6297 +
  8.6298 +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  8.6299 +
  8.6300 +#ifndef VK_NO_PROTOTYPES
  8.6301 +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
  8.6302 +    VkInstance                                  instance,
  8.6303 +    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
  8.6304 +    const VkAllocationCallbacks*                pAllocator,
  8.6305 +    VkSurfaceKHR*                               pSurface);
  8.6306 +#endif
  8.6307 +#endif /* VK_USE_PLATFORM_MACOS_MVK */
  8.6308 +
  8.6309 +#define VK_EXT_sampler_filter_minmax 1
  8.6310 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
  8.6311 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
  8.6312 +
  8.6313 +
  8.6314 +typedef enum VkSamplerReductionModeEXT {
  8.6315 +    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
  8.6316 +    VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
  8.6317 +    VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
  8.6318 +    VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
  8.6319 +    VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT,
  8.6320 +    VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1),
  8.6321 +    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
  8.6322 +} VkSamplerReductionModeEXT;
  8.6323 +
  8.6324 +typedef struct VkSamplerReductionModeCreateInfoEXT {
  8.6325 +    VkStructureType              sType;
  8.6326 +    const void*                  pNext;
  8.6327 +    VkSamplerReductionModeEXT    reductionMode;
  8.6328 +} VkSamplerReductionModeCreateInfoEXT;
  8.6329 +
  8.6330 +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
  8.6331 +    VkStructureType    sType;
  8.6332 +    void*              pNext;
  8.6333 +    VkBool32           filterMinmaxSingleComponentFormats;
  8.6334 +    VkBool32           filterMinmaxImageComponentMapping;
  8.6335 +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
  8.6336 +
  8.6337 +
  8.6338 +
  8.6339 +#define VK_AMD_gpu_shader_int16 1
  8.6340 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1
  8.6341 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
  8.6342 +
  8.6343 +
  8.6344 +#define VK_AMD_mixed_attachment_samples 1
  8.6345 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
  8.6346 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
  8.6347 +
  8.6348 +
  8.6349 +#define VK_EXT_shader_stencil_export 1
  8.6350 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
  8.6351 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
  8.6352 +
  8.6353 +
  8.6354 +#define VK_EXT_blend_operation_advanced 1
  8.6355 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
  8.6356 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
  8.6357 +
  8.6358 +
  8.6359 +typedef enum VkBlendOverlapEXT {
  8.6360 +    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
  8.6361 +    VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
  8.6362 +    VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
  8.6363 +    VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
  8.6364 +    VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT,
  8.6365 +    VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1),
  8.6366 +    VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
  8.6367 +} VkBlendOverlapEXT;
  8.6368 +
  8.6369 +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
  8.6370 +    VkStructureType    sType;
  8.6371 +    void*              pNext;
  8.6372 +    VkBool32           advancedBlendCoherentOperations;
  8.6373 +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
  8.6374 +
  8.6375 +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
  8.6376 +    VkStructureType    sType;
  8.6377 +    void*              pNext;
  8.6378 +    uint32_t           advancedBlendMaxColorAttachments;
  8.6379 +    VkBool32           advancedBlendIndependentBlend;
  8.6380 +    VkBool32           advancedBlendNonPremultipliedSrcColor;
  8.6381 +    VkBool32           advancedBlendNonPremultipliedDstColor;
  8.6382 +    VkBool32           advancedBlendCorrelatedOverlap;
  8.6383 +    VkBool32           advancedBlendAllOperations;
  8.6384 +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
  8.6385 +
  8.6386 +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
  8.6387 +    VkStructureType      sType;
  8.6388 +    const void*          pNext;
  8.6389 +    VkBool32             srcPremultiplied;
  8.6390 +    VkBool32             dstPremultiplied;
  8.6391 +    VkBlendOverlapEXT    blendOverlap;
  8.6392 +} VkPipelineColorBlendAdvancedStateCreateInfoEXT;
  8.6393 +
  8.6394 +
  8.6395 +
  8.6396 +#define VK_NV_fragment_coverage_to_color 1
  8.6397 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
  8.6398 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
  8.6399 +
  8.6400 +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
  8.6401 +
  8.6402 +typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
  8.6403 +    VkStructureType                                sType;
  8.6404 +    const void*                                    pNext;
  8.6405 +    VkPipelineCoverageToColorStateCreateFlagsNV    flags;
  8.6406 +    VkBool32                                       coverageToColorEnable;
  8.6407 +    uint32_t                                       coverageToColorLocation;
  8.6408 +} VkPipelineCoverageToColorStateCreateInfoNV;
  8.6409 +
  8.6410 +
  8.6411 +
  8.6412 +#define VK_NV_framebuffer_mixed_samples 1
  8.6413 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
  8.6414 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
  8.6415 +
  8.6416 +
  8.6417 +typedef enum VkCoverageModulationModeNV {
  8.6418 +    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
  8.6419 +    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
  8.6420 +    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
  8.6421 +    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
  8.6422 +    VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV,
  8.6423 +    VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV,
  8.6424 +    VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1),
  8.6425 +    VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
  8.6426 +} VkCoverageModulationModeNV;
  8.6427 +
  8.6428 +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
  8.6429 +
  8.6430 +typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
  8.6431 +    VkStructureType                                   sType;
  8.6432 +    const void*                                       pNext;
  8.6433 +    VkPipelineCoverageModulationStateCreateFlagsNV    flags;
  8.6434 +    VkCoverageModulationModeNV                        coverageModulationMode;
  8.6435 +    VkBool32                                          coverageModulationTableEnable;
  8.6436 +    uint32_t                                          coverageModulationTableCount;
  8.6437 +    const float*                                      pCoverageModulationTable;
  8.6438 +} VkPipelineCoverageModulationStateCreateInfoNV;
  8.6439 +
  8.6440 +
  8.6441 +
  8.6442 +#define VK_NV_fill_rectangle 1
  8.6443 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
  8.6444 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
  8.6445 +
  8.6446 +
  8.6447 +#define VK_EXT_post_depth_coverage 1
  8.6448 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
  8.6449 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
  8.6450 +
  8.6451 +
  8.6452 +#define VK_EXT_shader_viewport_index_layer 1
  8.6453 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
  8.6454 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
  8.6455 +
  8.6456 +
  8.6457 +#ifdef __cplusplus
  8.6458 +}
  8.6459 +#endif
  8.6460 +
  8.6461 +#endif
     9.1 --- a/test/testvulkan.c	Sun Aug 27 19:32:08 2017 -0700
     9.2 +++ b/test/testvulkan.c	Sun Aug 27 23:25:12 2017 -0400
     9.3 @@ -31,7 +31,7 @@
     9.4  #else
     9.5  
     9.6  #define VK_NO_PROTOTYPES
     9.7 -#include "vulkan/vulkan.h"
     9.8 +#include "../src/video/khronos/vulkan/vulkan.h"
     9.9  
    9.10  #define VULKAN_FUNCTIONS()                                              \
    9.11      VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR)                       \