Added Vulkan headers version 1.1.91
authorSam Lantinga <slouken@libsdl.org>
Tue, 06 Nov 2018 16:57:07 -0800
changeset 1240177433beaf97a
parent 12400 28303fca62bd
child 12402 3b5b4eb1927f
Added Vulkan headers version 1.1.91
Downloaded from https://github.com/KhronosGroup/Vulkan-Headers
src/video/khronos/vulkan/vk_icd.h
src/video/khronos/vulkan/vk_layer.h
src/video/khronos/vulkan/vk_platform.h
src/video/khronos/vulkan/vk_sdk_platform.h
src/video/khronos/vulkan/vulkan.h
src/video/khronos/vulkan/vulkan.hpp
src/video/khronos/vulkan/vulkan_android.h
src/video/khronos/vulkan/vulkan_core.h
src/video/khronos/vulkan/vulkan_fuchsia.h
src/video/khronos/vulkan/vulkan_ios.h
src/video/khronos/vulkan/vulkan_macos.h
src/video/khronos/vulkan/vulkan_mir.h
src/video/khronos/vulkan/vulkan_vi.h
src/video/khronos/vulkan/vulkan_wayland.h
src/video/khronos/vulkan/vulkan_win32.h
src/video/khronos/vulkan/vulkan_xcb.h
src/video/khronos/vulkan/vulkan_xlib.h
src/video/khronos/vulkan/vulkan_xlib_xrandr.h
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/src/video/khronos/vulkan/vk_icd.h	Tue Nov 06 16:57:07 2018 -0800
     1.3 @@ -0,0 +1,170 @@
     1.4 +//
     1.5 +// File: vk_icd.h
     1.6 +//
     1.7 +/*
     1.8 + * Copyright (c) 2015-2016 The Khronos Group Inc.
     1.9 + * Copyright (c) 2015-2016 Valve Corporation
    1.10 + * Copyright (c) 2015-2016 LunarG, Inc.
    1.11 + *
    1.12 + * Licensed under the Apache License, Version 2.0 (the "License");
    1.13 + * you may not use this file except in compliance with the License.
    1.14 + * You may obtain a copy of the License at
    1.15 + *
    1.16 + *     http://www.apache.org/licenses/LICENSE-2.0
    1.17 + *
    1.18 + * Unless required by applicable law or agreed to in writing, software
    1.19 + * distributed under the License is distributed on an "AS IS" BASIS,
    1.20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    1.21 + * See the License for the specific language governing permissions and
    1.22 + * limitations under the License.
    1.23 + *
    1.24 + */
    1.25 +
    1.26 +#ifndef VKICD_H
    1.27 +#define VKICD_H
    1.28 +
    1.29 +#include "vulkan.h"
    1.30 +#include <stdbool.h>
    1.31 +
    1.32 +// Loader-ICD version negotiation API.  Versions add the following features:
    1.33 +//   Version 0 - Initial.  Doesn't support vk_icdGetInstanceProcAddr
    1.34 +//               or vk_icdNegotiateLoaderICDInterfaceVersion.
    1.35 +//   Version 1 - Add support for vk_icdGetInstanceProcAddr.
    1.36 +//   Version 2 - Add Loader/ICD Interface version negotiation
    1.37 +//               via vk_icdNegotiateLoaderICDInterfaceVersion.
    1.38 +//   Version 3 - Add ICD creation/destruction of KHR_surface objects.
    1.39 +//   Version 4 - Add unknown physical device extension qyering via
    1.40 +//               vk_icdGetPhysicalDeviceProcAddr.
    1.41 +//   Version 5 - Tells ICDs that the loader is now paying attention to the
    1.42 +//               application version of Vulkan passed into the ApplicationInfo
    1.43 +//               structure during vkCreateInstance.  This will tell the ICD
    1.44 +//               that if the loader is older, it should automatically fail a
    1.45 +//               call for any API version > 1.0.  Otherwise, the loader will
    1.46 +//               manually determine if it can support the expected version.
    1.47 +#define CURRENT_LOADER_ICD_INTERFACE_VERSION 5
    1.48 +#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
    1.49 +#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
    1.50 +typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
    1.51 +
    1.52 +// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
    1.53 +// file directly, it won't be found.
    1.54 +#ifndef PFN_GetPhysicalDeviceProcAddr
    1.55 +typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
    1.56 +#endif
    1.57 +
    1.58 +/*
    1.59 + * The ICD must reserve space for a pointer for the loader's dispatch
    1.60 + * table, at the start of <each object>.
    1.61 + * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
    1.62 + */
    1.63 +
    1.64 +#define ICD_LOADER_MAGIC 0x01CDC0DE
    1.65 +
    1.66 +typedef union {
    1.67 +    uintptr_t loaderMagic;
    1.68 +    void *loaderData;
    1.69 +} VK_LOADER_DATA;
    1.70 +
    1.71 +static inline void set_loader_magic_value(void *pNewObject) {
    1.72 +    VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
    1.73 +    loader_info->loaderMagic = ICD_LOADER_MAGIC;
    1.74 +}
    1.75 +
    1.76 +static inline bool valid_loader_magic_value(void *pNewObject) {
    1.77 +    const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
    1.78 +    return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
    1.79 +}
    1.80 +
    1.81 +/*
    1.82 + * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
    1.83 + * contains the platform-specific connection and surface information.
    1.84 + */
    1.85 +typedef enum {
    1.86 +    VK_ICD_WSI_PLATFORM_MIR,
    1.87 +    VK_ICD_WSI_PLATFORM_WAYLAND,
    1.88 +    VK_ICD_WSI_PLATFORM_WIN32,
    1.89 +    VK_ICD_WSI_PLATFORM_XCB,
    1.90 +    VK_ICD_WSI_PLATFORM_XLIB,
    1.91 +    VK_ICD_WSI_PLATFORM_ANDROID,
    1.92 +    VK_ICD_WSI_PLATFORM_MACOS,
    1.93 +    VK_ICD_WSI_PLATFORM_IOS,
    1.94 +    VK_ICD_WSI_PLATFORM_DISPLAY
    1.95 +} VkIcdWsiPlatform;
    1.96 +
    1.97 +typedef struct {
    1.98 +    VkIcdWsiPlatform platform;
    1.99 +} VkIcdSurfaceBase;
   1.100 +
   1.101 +#ifdef VK_USE_PLATFORM_MIR_KHR
   1.102 +typedef struct {
   1.103 +    VkIcdSurfaceBase base;
   1.104 +    MirConnection *connection;
   1.105 +    MirSurface *mirSurface;
   1.106 +} VkIcdSurfaceMir;
   1.107 +#endif  // VK_USE_PLATFORM_MIR_KHR
   1.108 +
   1.109 +#ifdef VK_USE_PLATFORM_WAYLAND_KHR
   1.110 +typedef struct {
   1.111 +    VkIcdSurfaceBase base;
   1.112 +    struct wl_display *display;
   1.113 +    struct wl_surface *surface;
   1.114 +} VkIcdSurfaceWayland;
   1.115 +#endif  // VK_USE_PLATFORM_WAYLAND_KHR
   1.116 +
   1.117 +#ifdef VK_USE_PLATFORM_WIN32_KHR
   1.118 +typedef struct {
   1.119 +    VkIcdSurfaceBase base;
   1.120 +    HINSTANCE hinstance;
   1.121 +    HWND hwnd;
   1.122 +} VkIcdSurfaceWin32;
   1.123 +#endif  // VK_USE_PLATFORM_WIN32_KHR
   1.124 +
   1.125 +#ifdef VK_USE_PLATFORM_XCB_KHR
   1.126 +typedef struct {
   1.127 +    VkIcdSurfaceBase base;
   1.128 +    xcb_connection_t *connection;
   1.129 +    xcb_window_t window;
   1.130 +} VkIcdSurfaceXcb;
   1.131 +#endif  // VK_USE_PLATFORM_XCB_KHR
   1.132 +
   1.133 +#ifdef VK_USE_PLATFORM_XLIB_KHR
   1.134 +typedef struct {
   1.135 +    VkIcdSurfaceBase base;
   1.136 +    Display *dpy;
   1.137 +    Window window;
   1.138 +} VkIcdSurfaceXlib;
   1.139 +#endif  // VK_USE_PLATFORM_XLIB_KHR
   1.140 +
   1.141 +#ifdef VK_USE_PLATFORM_ANDROID_KHR
   1.142 +typedef struct {
   1.143 +    VkIcdSurfaceBase base;
   1.144 +    struct ANativeWindow *window;
   1.145 +} VkIcdSurfaceAndroid;
   1.146 +#endif  // VK_USE_PLATFORM_ANDROID_KHR
   1.147 +
   1.148 +#ifdef VK_USE_PLATFORM_MACOS_MVK
   1.149 +typedef struct {
   1.150 +    VkIcdSurfaceBase base;
   1.151 +    const void *pView;
   1.152 +} VkIcdSurfaceMacOS;
   1.153 +#endif  // VK_USE_PLATFORM_MACOS_MVK
   1.154 +
   1.155 +#ifdef VK_USE_PLATFORM_IOS_MVK
   1.156 +typedef struct {
   1.157 +    VkIcdSurfaceBase base;
   1.158 +    const void *pView;
   1.159 +} VkIcdSurfaceIOS;
   1.160 +#endif  // VK_USE_PLATFORM_IOS_MVK
   1.161 +
   1.162 +typedef struct {
   1.163 +    VkIcdSurfaceBase base;
   1.164 +    VkDisplayModeKHR displayMode;
   1.165 +    uint32_t planeIndex;
   1.166 +    uint32_t planeStackIndex;
   1.167 +    VkSurfaceTransformFlagBitsKHR transform;
   1.168 +    float globalAlpha;
   1.169 +    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
   1.170 +    VkExtent2D imageExtent;
   1.171 +} VkIcdSurfaceDisplay;
   1.172 +
   1.173 +#endif  // VKICD_H
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/src/video/khronos/vulkan/vk_layer.h	Tue Nov 06 16:57:07 2018 -0800
     2.3 @@ -0,0 +1,195 @@
     2.4 +//
     2.5 +// File: vk_layer.h
     2.6 +//
     2.7 +/*
     2.8 + * Copyright (c) 2015-2017 The Khronos Group Inc.
     2.9 + * Copyright (c) 2015-2017 Valve Corporation
    2.10 + * Copyright (c) 2015-2017 LunarG, Inc.
    2.11 + *
    2.12 + * Licensed under the Apache License, Version 2.0 (the "License");
    2.13 + * you may not use this file except in compliance with the License.
    2.14 + * You may obtain a copy of the License at
    2.15 + *
    2.16 + *     http://www.apache.org/licenses/LICENSE-2.0
    2.17 + *
    2.18 + * Unless required by applicable law or agreed to in writing, software
    2.19 + * distributed under the License is distributed on an "AS IS" BASIS,
    2.20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    2.21 + * See the License for the specific language governing permissions and
    2.22 + * limitations under the License.
    2.23 + *
    2.24 + */
    2.25 +
    2.26 +/* Need to define dispatch table
    2.27 + * Core struct can then have ptr to dispatch table at the top
    2.28 + * Along with object ptrs for current and next OBJ
    2.29 + */
    2.30 +#pragma once
    2.31 +
    2.32 +#include "vulkan.h"
    2.33 +#if defined(__GNUC__) && __GNUC__ >= 4
    2.34 +#define VK_LAYER_EXPORT __attribute__((visibility("default")))
    2.35 +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
    2.36 +#define VK_LAYER_EXPORT __attribute__((visibility("default")))
    2.37 +#else
    2.38 +#define VK_LAYER_EXPORT
    2.39 +#endif
    2.40 +
    2.41 +#define MAX_NUM_UNKNOWN_EXTS 250
    2.42 +
    2.43 + // Loader-Layer version negotiation API.  Versions add the following features:
    2.44 + //   Versions 0/1 - Initial.  Doesn't support vk_layerGetPhysicalDeviceProcAddr
    2.45 + //                  or vk_icdNegotiateLoaderLayerInterfaceVersion.
    2.46 + //   Version 2    - Add support for vk_layerGetPhysicalDeviceProcAddr and
    2.47 + //                  vk_icdNegotiateLoaderLayerInterfaceVersion.
    2.48 +#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
    2.49 +#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
    2.50 +
    2.51 +#define VK_CURRENT_CHAIN_VERSION 1
    2.52 +
    2.53 +// Typedef for use in the interfaces below
    2.54 +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
    2.55 +
    2.56 +// Version negotiation values
    2.57 +typedef enum VkNegotiateLayerStructType {
    2.58 +    LAYER_NEGOTIATE_UNINTIALIZED = 0,
    2.59 +    LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
    2.60 +} VkNegotiateLayerStructType;
    2.61 +
    2.62 +// Version negotiation structures
    2.63 +typedef struct VkNegotiateLayerInterface {
    2.64 +    VkNegotiateLayerStructType sType;
    2.65 +    void *pNext;
    2.66 +    uint32_t loaderLayerInterfaceVersion;
    2.67 +    PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
    2.68 +    PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
    2.69 +    PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
    2.70 +} VkNegotiateLayerInterface;
    2.71 +
    2.72 +// Version negotiation functions
    2.73 +typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
    2.74 +
    2.75 +// Function prototype for unknown physical device extension command
    2.76 +typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
    2.77 +
    2.78 +// ------------------------------------------------------------------------------------------------
    2.79 +// CreateInstance and CreateDevice support structures
    2.80 +
    2.81 +/* Sub type of structure for instance and device loader ext of CreateInfo.
    2.82 + * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
    2.83 + * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
    2.84 + * then VkLayerFunction indicates struct type pointed to by pNext
    2.85 + */
    2.86 +typedef enum VkLayerFunction_ {
    2.87 +    VK_LAYER_LINK_INFO = 0,
    2.88 +    VK_LOADER_DATA_CALLBACK = 1
    2.89 +} VkLayerFunction;
    2.90 +
    2.91 +typedef struct VkLayerInstanceLink_ {
    2.92 +    struct VkLayerInstanceLink_ *pNext;
    2.93 +    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
    2.94 +    PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
    2.95 +} VkLayerInstanceLink;
    2.96 +
    2.97 +/*
    2.98 + * When creating the device chain the loader needs to pass
    2.99 + * down information about it's device structure needed at
   2.100 + * the end of the chain. Passing the data via the
   2.101 + * VkLayerDeviceInfo avoids issues with finding the
   2.102 + * exact instance being used.
   2.103 + */
   2.104 +typedef struct VkLayerDeviceInfo_ {
   2.105 +    void *device_info;
   2.106 +    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
   2.107 +} VkLayerDeviceInfo;
   2.108 +
   2.109 +typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
   2.110 +        void *object);
   2.111 +typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
   2.112 +        void *object);
   2.113 +
   2.114 +typedef struct {
   2.115 +    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
   2.116 +    const void *pNext;
   2.117 +    VkLayerFunction function;
   2.118 +    union {
   2.119 +        VkLayerInstanceLink *pLayerInfo;
   2.120 +        PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
   2.121 +    } u;
   2.122 +} VkLayerInstanceCreateInfo;
   2.123 +
   2.124 +typedef struct VkLayerDeviceLink_ {
   2.125 +    struct VkLayerDeviceLink_ *pNext;
   2.126 +    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
   2.127 +    PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
   2.128 +} VkLayerDeviceLink;
   2.129 +
   2.130 +typedef struct {
   2.131 +    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
   2.132 +    const void *pNext;
   2.133 +    VkLayerFunction function;
   2.134 +    union {
   2.135 +        VkLayerDeviceLink *pLayerInfo;
   2.136 +        PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
   2.137 +    } u;
   2.138 +} VkLayerDeviceCreateInfo;
   2.139 +
   2.140 +#ifdef __cplusplus
   2.141 +extern "C" {
   2.142 +#endif
   2.143 +
   2.144 +VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
   2.145 +
   2.146 +typedef enum VkChainType {
   2.147 +    VK_CHAIN_TYPE_UNKNOWN = 0,
   2.148 +    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
   2.149 +    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
   2.150 +    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
   2.151 +} VkChainType;
   2.152 +
   2.153 +typedef struct VkChainHeader {
   2.154 +    VkChainType type;
   2.155 +    uint32_t version;
   2.156 +    uint32_t size;
   2.157 +} VkChainHeader;
   2.158 +
   2.159 +typedef struct VkEnumerateInstanceExtensionPropertiesChain {
   2.160 +    VkChainHeader header;
   2.161 +    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
   2.162 +                                      VkExtensionProperties *);
   2.163 +    const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
   2.164 +
   2.165 +#if defined(__cplusplus)
   2.166 +    inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
   2.167 +        return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
   2.168 +    }
   2.169 +#endif
   2.170 +} VkEnumerateInstanceExtensionPropertiesChain;
   2.171 +
   2.172 +typedef struct VkEnumerateInstanceLayerPropertiesChain {
   2.173 +    VkChainHeader header;
   2.174 +    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
   2.175 +    const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
   2.176 +
   2.177 +#if defined(__cplusplus)
   2.178 +    inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
   2.179 +        return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
   2.180 +    }
   2.181 +#endif
   2.182 +} VkEnumerateInstanceLayerPropertiesChain;
   2.183 +
   2.184 +typedef struct VkEnumerateInstanceVersionChain {
   2.185 +    VkChainHeader header;
   2.186 +    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
   2.187 +    const struct VkEnumerateInstanceVersionChain *pNextLink;
   2.188 +
   2.189 +#if defined(__cplusplus)
   2.190 +    inline VkResult CallDown(uint32_t *pApiVersion) const {
   2.191 +        return pfnNextLayer(pNextLink, pApiVersion);
   2.192 +    }
   2.193 +#endif
   2.194 +} VkEnumerateInstanceVersionChain;
   2.195 +
   2.196 +#ifdef __cplusplus
   2.197 +}
   2.198 +#endif
     3.1 --- a/src/video/khronos/vulkan/vk_platform.h	Wed Nov 07 01:08:35 2018 +0100
     3.2 +++ b/src/video/khronos/vulkan/vk_platform.h	Tue Nov 06 16:57:07 2018 -0800
     3.3 @@ -89,32 +89,4 @@
     3.4  } // extern "C"
     3.5  #endif // __cplusplus
     3.6  
     3.7 -// Platform-specific headers required by platform window system extensions.
     3.8 -// These are enabled prior to #including "vulkan.h". The same enable then
     3.9 -// controls inclusion of the extension interfaces in vulkan.h.
    3.10 -
    3.11 -#ifdef VK_USE_PLATFORM_ANDROID_KHR
    3.12 -#include <android/native_window.h>
    3.13  #endif
    3.14 -
    3.15 -#ifdef VK_USE_PLATFORM_MIR_KHR
    3.16 -#include <mir_toolkit/client_types.h>
    3.17 -#endif
    3.18 -
    3.19 -#ifdef VK_USE_PLATFORM_WAYLAND_KHR
    3.20 -#include <wayland-client.h>
    3.21 -#endif
    3.22 -
    3.23 -#ifdef VK_USE_PLATFORM_WIN32_KHR
    3.24 -#include <windows.h>
    3.25 -#endif
    3.26 -
    3.27 -#ifdef VK_USE_PLATFORM_XLIB_KHR
    3.28 -#include <X11/Xlib.h>
    3.29 -#endif
    3.30 -
    3.31 -#ifdef VK_USE_PLATFORM_XCB_KHR
    3.32 -#include <xcb/xcb.h>
    3.33 -#endif
    3.34 -
    3.35 -#endif
     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/src/video/khronos/vulkan/vk_sdk_platform.h	Tue Nov 06 16:57:07 2018 -0800
     4.3 @@ -0,0 +1,69 @@
     4.4 +//
     4.5 +// File: vk_sdk_platform.h
     4.6 +//
     4.7 +/*
     4.8 + * Copyright (c) 2015-2016 The Khronos Group Inc.
     4.9 + * Copyright (c) 2015-2016 Valve Corporation
    4.10 + * Copyright (c) 2015-2016 LunarG, Inc.
    4.11 + *
    4.12 + * Licensed under the Apache License, Version 2.0 (the "License");
    4.13 + * you may not use this file except in compliance with the License.
    4.14 + * You may obtain a copy of the License at
    4.15 + *
    4.16 + *     http://www.apache.org/licenses/LICENSE-2.0
    4.17 + *
    4.18 + * Unless required by applicable law or agreed to in writing, software
    4.19 + * distributed under the License is distributed on an "AS IS" BASIS,
    4.20 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    4.21 + * See the License for the specific language governing permissions and
    4.22 + * limitations under the License.
    4.23 + */
    4.24 +
    4.25 +#ifndef VK_SDK_PLATFORM_H
    4.26 +#define VK_SDK_PLATFORM_H
    4.27 +
    4.28 +#if defined(_WIN32)
    4.29 +#define NOMINMAX
    4.30 +#ifndef __cplusplus
    4.31 +#undef inline
    4.32 +#define inline __inline
    4.33 +#endif // __cplusplus
    4.34 +
    4.35 +#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
    4.36 +// C99:
    4.37 +// Microsoft didn't implement C99 in Visual Studio; but started adding it with
    4.38 +// VS2013.  However, VS2013 still didn't have snprintf().  The following is a
    4.39 +// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
    4.40 +// "CMakeLists.txt" file).
    4.41 +// NOTE: This is fixed in Visual Studio 2015.
    4.42 +#define snprintf _snprintf
    4.43 +#endif
    4.44 +
    4.45 +#define strdup _strdup
    4.46 +
    4.47 +#endif // _WIN32
    4.48 +
    4.49 +// Check for noexcept support using clang, with fallback to Windows or GCC version numbers
    4.50 +#ifndef NOEXCEPT
    4.51 +#if defined(__clang__)
    4.52 +#if __has_feature(cxx_noexcept)
    4.53 +#define HAS_NOEXCEPT
    4.54 +#endif
    4.55 +#else
    4.56 +#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
    4.57 +#define HAS_NOEXCEPT
    4.58 +#else
    4.59 +#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
    4.60 +#define HAS_NOEXCEPT
    4.61 +#endif
    4.62 +#endif
    4.63 +#endif
    4.64 +
    4.65 +#ifdef HAS_NOEXCEPT
    4.66 +#define NOEXCEPT noexcept
    4.67 +#else
    4.68 +#define NOEXCEPT
    4.69 +#endif
    4.70 +#endif
    4.71 +
    4.72 +#endif  // VK_SDK_PLATFORM_H
     5.1 --- a/src/video/khronos/vulkan/vulkan.h	Wed Nov 07 01:08:35 2018 +0100
     5.2 +++ b/src/video/khronos/vulkan/vulkan.h	Tue Nov 06 16:57:07 2018 -0800
     5.3 @@ -1,12 +1,8 @@
     5.4  #ifndef VULKAN_H_
     5.5  #define VULKAN_H_ 1
     5.6  
     5.7 -#ifdef __cplusplus
     5.8 -extern "C" {
     5.9 -#endif
    5.10 -
    5.11  /*
    5.12 -** Copyright (c) 2015-2017 The Khronos Group Inc.
    5.13 +** Copyright (c) 2015-2018 The Khronos Group Inc.
    5.14  **
    5.15  ** Licensed under the Apache License, Version 2.0 (the "License");
    5.16  ** you may not use this file except in compliance with the License.
    5.17 @@ -21,6438 +17,61 @@
    5.18  ** limitations under the License.
    5.19  */
    5.20  
    5.21 -/*
    5.22 -** This header is generated from the Khronos Vulkan XML API Registry.
    5.23 -**
    5.24 -*/
    5.25 +#include "vk_platform.h"
    5.26 +#include "vulkan_core.h"
    5.27  
    5.28 -
    5.29 -#define VK_VERSION_1_0 1
    5.30 -#include "./vk_platform.h"
    5.31 -
    5.32 -#define VK_MAKE_VERSION(major, minor, patch) \
    5.33 -    (((major) << 22) | ((minor) << 12) | (patch))
    5.34 -
    5.35 -// 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.
    5.36 -//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
    5.37 -
    5.38 -// Vulkan 1.0 version number
    5.39 -#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
    5.40 -
    5.41 -#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
    5.42 -#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
    5.43 -#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
    5.44 -// Version of this file
    5.45 -#define VK_HEADER_VERSION 59
    5.46 -
    5.47 -
    5.48 -#define VK_NULL_HANDLE 0
    5.49 -        
    5.50 -
    5.51 -
    5.52 -#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
    5.53 -
    5.54 -
    5.55 -#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
    5.56 -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
    5.57 -        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
    5.58 -#else
    5.59 -        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
    5.60 -#endif
    5.61 -#endif
    5.62 -        
    5.63 -
    5.64 -
    5.65 -typedef uint32_t VkFlags;
    5.66 -typedef uint32_t VkBool32;
    5.67 -typedef uint64_t VkDeviceSize;
    5.68 -typedef uint32_t VkSampleMask;
    5.69 -
    5.70 -VK_DEFINE_HANDLE(VkInstance)
    5.71 -VK_DEFINE_HANDLE(VkPhysicalDevice)
    5.72 -VK_DEFINE_HANDLE(VkDevice)
    5.73 -VK_DEFINE_HANDLE(VkQueue)
    5.74 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
    5.75 -VK_DEFINE_HANDLE(VkCommandBuffer)
    5.76 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
    5.77 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
    5.78 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
    5.79 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
    5.80 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
    5.81 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
    5.82 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
    5.83 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
    5.84 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
    5.85 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
    5.86 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
    5.87 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
    5.88 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
    5.89 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
    5.90 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
    5.91 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
    5.92 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
    5.93 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
    5.94 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
    5.95 -
    5.96 -#define VK_LOD_CLAMP_NONE                 1000.0f
    5.97 -#define VK_REMAINING_MIP_LEVELS           (~0U)
    5.98 -#define VK_REMAINING_ARRAY_LAYERS         (~0U)
    5.99 -#define VK_WHOLE_SIZE                     (~0ULL)
   5.100 -#define VK_ATTACHMENT_UNUSED              (~0U)
   5.101 -#define VK_TRUE                           1
   5.102 -#define VK_FALSE                          0
   5.103 -#define VK_QUEUE_FAMILY_IGNORED           (~0U)
   5.104 -#define VK_SUBPASS_EXTERNAL               (~0U)
   5.105 -#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
   5.106 -#define VK_UUID_SIZE                      16
   5.107 -#define VK_MAX_MEMORY_TYPES               32
   5.108 -#define VK_MAX_MEMORY_HEAPS               16
   5.109 -#define VK_MAX_EXTENSION_NAME_SIZE        256
   5.110 -#define VK_MAX_DESCRIPTION_SIZE           256
   5.111 -
   5.112 -
   5.113 -typedef enum VkPipelineCacheHeaderVersion {
   5.114 -    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
   5.115 -    VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
   5.116 -    VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
   5.117 -    VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
   5.118 -    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
   5.119 -} VkPipelineCacheHeaderVersion;
   5.120 -
   5.121 -typedef enum VkResult {
   5.122 -    VK_SUCCESS = 0,
   5.123 -    VK_NOT_READY = 1,
   5.124 -    VK_TIMEOUT = 2,
   5.125 -    VK_EVENT_SET = 3,
   5.126 -    VK_EVENT_RESET = 4,
   5.127 -    VK_INCOMPLETE = 5,
   5.128 -    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
   5.129 -    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
   5.130 -    VK_ERROR_INITIALIZATION_FAILED = -3,
   5.131 -    VK_ERROR_DEVICE_LOST = -4,
   5.132 -    VK_ERROR_MEMORY_MAP_FAILED = -5,
   5.133 -    VK_ERROR_LAYER_NOT_PRESENT = -6,
   5.134 -    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
   5.135 -    VK_ERROR_FEATURE_NOT_PRESENT = -8,
   5.136 -    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
   5.137 -    VK_ERROR_TOO_MANY_OBJECTS = -10,
   5.138 -    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
   5.139 -    VK_ERROR_FRAGMENTED_POOL = -12,
   5.140 -    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
   5.141 -    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
   5.142 -    VK_SUBOPTIMAL_KHR = 1000001003,
   5.143 -    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
   5.144 -    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
   5.145 -    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
   5.146 -    VK_ERROR_INVALID_SHADER_NV = -1000012000,
   5.147 -    VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
   5.148 -    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003,
   5.149 -    VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
   5.150 -    VK_RESULT_END_RANGE = VK_INCOMPLETE,
   5.151 -    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
   5.152 -    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
   5.153 -} VkResult;
   5.154 -
   5.155 -typedef enum VkStructureType {
   5.156 -    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
   5.157 -    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
   5.158 -    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
   5.159 -    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
   5.160 -    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
   5.161 -    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
   5.162 -    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
   5.163 -    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
   5.164 -    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
   5.165 -    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
   5.166 -    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
   5.167 -    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
   5.168 -    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
   5.169 -    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
   5.170 -    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
   5.171 -    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
   5.172 -    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
   5.173 -    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
   5.174 -    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
   5.175 -    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
   5.176 -    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
   5.177 -    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
   5.178 -    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
   5.179 -    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
   5.180 -    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
   5.181 -    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
   5.182 -    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
   5.183 -    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
   5.184 -    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
   5.185 -    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
   5.186 -    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
   5.187 -    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
   5.188 -    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
   5.189 -    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
   5.190 -    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
   5.191 -    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
   5.192 -    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
   5.193 -    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
   5.194 -    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
   5.195 -    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
   5.196 -    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
   5.197 -    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
   5.198 -    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
   5.199 -    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
   5.200 -    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
   5.201 -    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
   5.202 -    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
   5.203 -    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
   5.204 -    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
   5.205 -    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
   5.206 -    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
   5.207 -    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
   5.208 -    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
   5.209 -    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
   5.210 -    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
   5.211 -    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
   5.212 -    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
   5.213 -    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
   5.214 -    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
   5.215 -    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
   5.216 -    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
   5.217 -    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
   5.218 -    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
   5.219 -    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
   5.220 -    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
   5.221 -    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
   5.222 -    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
   5.223 -    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
   5.224 -    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
   5.225 -    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
   5.226 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
   5.227 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
   5.228 -    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
   5.229 -    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
   5.230 -    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
   5.231 -    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
   5.232 -    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
   5.233 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
   5.234 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
   5.235 -    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
   5.236 -    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
   5.237 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
   5.238 -    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
   5.239 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
   5.240 -    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
   5.241 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
   5.242 -    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000,
   5.243 -    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = 1000060001,
   5.244 -    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = 1000060002,
   5.245 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003,
   5.246 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004,
   5.247 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005,
   5.248 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006,
   5.249 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007,
   5.250 -    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008,
   5.251 -    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009,
   5.252 -    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010,
   5.253 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011,
   5.254 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012,
   5.255 -    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
   5.256 -    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
   5.257 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000,
   5.258 -    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001,
   5.259 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000,
   5.260 -    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001,
   5.261 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002,
   5.262 -    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003,
   5.263 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004,
   5.264 -    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000,
   5.265 -    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001,
   5.266 -    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002,
   5.267 -    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
   5.268 -    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
   5.269 -    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
   5.270 -    VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
   5.271 -    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
   5.272 -    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
   5.273 -    VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
   5.274 -    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
   5.275 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000,
   5.276 -    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001,
   5.277 -    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000,
   5.278 -    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
   5.279 -    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
   5.280 -    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
   5.281 -    VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
   5.282 -    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
   5.283 -    VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
   5.284 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
   5.285 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
   5.286 -    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
   5.287 -    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
   5.288 -    VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
   5.289 -    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
   5.290 -    VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
   5.291 -    VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
   5.292 -    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
   5.293 -    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
   5.294 -    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
   5.295 -    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
   5.296 -    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
   5.297 -    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
   5.298 -    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
   5.299 -    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
   5.300 -    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
   5.301 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
   5.302 -    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
   5.303 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
   5.304 -    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
   5.305 -    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
   5.306 -    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
   5.307 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000,
   5.308 -    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001,
   5.309 -    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000,
   5.310 -    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
   5.311 -    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
   5.312 -    VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
   5.313 -    VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
   5.314 -    VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
   5.315 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
   5.316 -    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
   5.317 -    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
   5.318 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,
   5.319 -    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
   5.320 -    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
   5.321 -    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000,
   5.322 -    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001,
   5.323 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
   5.324 -    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
   5.325 -    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000,
   5.326 -    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001,
   5.327 -    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
   5.328 -    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003,
   5.329 -    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
   5.330 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
   5.331 -    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
   5.332 -    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
   5.333 -    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
   5.334 -    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
   5.335 -    VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
   5.336 -    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
   5.337 -    VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
   5.338 -    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.339 -} VkStructureType;
   5.340 -
   5.341 -typedef enum VkSystemAllocationScope {
   5.342 -    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
   5.343 -    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
   5.344 -    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
   5.345 -    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
   5.346 -    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
   5.347 -    VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
   5.348 -    VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
   5.349 -    VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
   5.350 -    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
   5.351 -} VkSystemAllocationScope;
   5.352 -
   5.353 -typedef enum VkInternalAllocationType {
   5.354 -    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
   5.355 -    VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
   5.356 -    VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
   5.357 -    VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
   5.358 -    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.359 -} VkInternalAllocationType;
   5.360 -
   5.361 -typedef enum VkFormat {
   5.362 -    VK_FORMAT_UNDEFINED = 0,
   5.363 -    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
   5.364 -    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
   5.365 -    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
   5.366 -    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
   5.367 -    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
   5.368 -    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
   5.369 -    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
   5.370 -    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
   5.371 -    VK_FORMAT_R8_UNORM = 9,
   5.372 -    VK_FORMAT_R8_SNORM = 10,
   5.373 -    VK_FORMAT_R8_USCALED = 11,
   5.374 -    VK_FORMAT_R8_SSCALED = 12,
   5.375 -    VK_FORMAT_R8_UINT = 13,
   5.376 -    VK_FORMAT_R8_SINT = 14,
   5.377 -    VK_FORMAT_R8_SRGB = 15,
   5.378 -    VK_FORMAT_R8G8_UNORM = 16,
   5.379 -    VK_FORMAT_R8G8_SNORM = 17,
   5.380 -    VK_FORMAT_R8G8_USCALED = 18,
   5.381 -    VK_FORMAT_R8G8_SSCALED = 19,
   5.382 -    VK_FORMAT_R8G8_UINT = 20,
   5.383 -    VK_FORMAT_R8G8_SINT = 21,
   5.384 -    VK_FORMAT_R8G8_SRGB = 22,
   5.385 -    VK_FORMAT_R8G8B8_UNORM = 23,
   5.386 -    VK_FORMAT_R8G8B8_SNORM = 24,
   5.387 -    VK_FORMAT_R8G8B8_USCALED = 25,
   5.388 -    VK_FORMAT_R8G8B8_SSCALED = 26,
   5.389 -    VK_FORMAT_R8G8B8_UINT = 27,
   5.390 -    VK_FORMAT_R8G8B8_SINT = 28,
   5.391 -    VK_FORMAT_R8G8B8_SRGB = 29,
   5.392 -    VK_FORMAT_B8G8R8_UNORM = 30,
   5.393 -    VK_FORMAT_B8G8R8_SNORM = 31,
   5.394 -    VK_FORMAT_B8G8R8_USCALED = 32,
   5.395 -    VK_FORMAT_B8G8R8_SSCALED = 33,
   5.396 -    VK_FORMAT_B8G8R8_UINT = 34,
   5.397 -    VK_FORMAT_B8G8R8_SINT = 35,
   5.398 -    VK_FORMAT_B8G8R8_SRGB = 36,
   5.399 -    VK_FORMAT_R8G8B8A8_UNORM = 37,
   5.400 -    VK_FORMAT_R8G8B8A8_SNORM = 38,
   5.401 -    VK_FORMAT_R8G8B8A8_USCALED = 39,
   5.402 -    VK_FORMAT_R8G8B8A8_SSCALED = 40,
   5.403 -    VK_FORMAT_R8G8B8A8_UINT = 41,
   5.404 -    VK_FORMAT_R8G8B8A8_SINT = 42,
   5.405 -    VK_FORMAT_R8G8B8A8_SRGB = 43,
   5.406 -    VK_FORMAT_B8G8R8A8_UNORM = 44,
   5.407 -    VK_FORMAT_B8G8R8A8_SNORM = 45,
   5.408 -    VK_FORMAT_B8G8R8A8_USCALED = 46,
   5.409 -    VK_FORMAT_B8G8R8A8_SSCALED = 47,
   5.410 -    VK_FORMAT_B8G8R8A8_UINT = 48,
   5.411 -    VK_FORMAT_B8G8R8A8_SINT = 49,
   5.412 -    VK_FORMAT_B8G8R8A8_SRGB = 50,
   5.413 -    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
   5.414 -    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
   5.415 -    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
   5.416 -    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
   5.417 -    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
   5.418 -    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
   5.419 -    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
   5.420 -    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
   5.421 -    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
   5.422 -    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
   5.423 -    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
   5.424 -    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
   5.425 -    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
   5.426 -    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
   5.427 -    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
   5.428 -    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
   5.429 -    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
   5.430 -    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
   5.431 -    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
   5.432 -    VK_FORMAT_R16_UNORM = 70,
   5.433 -    VK_FORMAT_R16_SNORM = 71,
   5.434 -    VK_FORMAT_R16_USCALED = 72,
   5.435 -    VK_FORMAT_R16_SSCALED = 73,
   5.436 -    VK_FORMAT_R16_UINT = 74,
   5.437 -    VK_FORMAT_R16_SINT = 75,
   5.438 -    VK_FORMAT_R16_SFLOAT = 76,
   5.439 -    VK_FORMAT_R16G16_UNORM = 77,
   5.440 -    VK_FORMAT_R16G16_SNORM = 78,
   5.441 -    VK_FORMAT_R16G16_USCALED = 79,
   5.442 -    VK_FORMAT_R16G16_SSCALED = 80,
   5.443 -    VK_FORMAT_R16G16_UINT = 81,
   5.444 -    VK_FORMAT_R16G16_SINT = 82,
   5.445 -    VK_FORMAT_R16G16_SFLOAT = 83,
   5.446 -    VK_FORMAT_R16G16B16_UNORM = 84,
   5.447 -    VK_FORMAT_R16G16B16_SNORM = 85,
   5.448 -    VK_FORMAT_R16G16B16_USCALED = 86,
   5.449 -    VK_FORMAT_R16G16B16_SSCALED = 87,
   5.450 -    VK_FORMAT_R16G16B16_UINT = 88,
   5.451 -    VK_FORMAT_R16G16B16_SINT = 89,
   5.452 -    VK_FORMAT_R16G16B16_SFLOAT = 90,
   5.453 -    VK_FORMAT_R16G16B16A16_UNORM = 91,
   5.454 -    VK_FORMAT_R16G16B16A16_SNORM = 92,
   5.455 -    VK_FORMAT_R16G16B16A16_USCALED = 93,
   5.456 -    VK_FORMAT_R16G16B16A16_SSCALED = 94,
   5.457 -    VK_FORMAT_R16G16B16A16_UINT = 95,
   5.458 -    VK_FORMAT_R16G16B16A16_SINT = 96,
   5.459 -    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
   5.460 -    VK_FORMAT_R32_UINT = 98,
   5.461 -    VK_FORMAT_R32_SINT = 99,
   5.462 -    VK_FORMAT_R32_SFLOAT = 100,
   5.463 -    VK_FORMAT_R32G32_UINT = 101,
   5.464 -    VK_FORMAT_R32G32_SINT = 102,
   5.465 -    VK_FORMAT_R32G32_SFLOAT = 103,
   5.466 -    VK_FORMAT_R32G32B32_UINT = 104,
   5.467 -    VK_FORMAT_R32G32B32_SINT = 105,
   5.468 -    VK_FORMAT_R32G32B32_SFLOAT = 106,
   5.469 -    VK_FORMAT_R32G32B32A32_UINT = 107,
   5.470 -    VK_FORMAT_R32G32B32A32_SINT = 108,
   5.471 -    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
   5.472 -    VK_FORMAT_R64_UINT = 110,
   5.473 -    VK_FORMAT_R64_SINT = 111,
   5.474 -    VK_FORMAT_R64_SFLOAT = 112,
   5.475 -    VK_FORMAT_R64G64_UINT = 113,
   5.476 -    VK_FORMAT_R64G64_SINT = 114,
   5.477 -    VK_FORMAT_R64G64_SFLOAT = 115,
   5.478 -    VK_FORMAT_R64G64B64_UINT = 116,
   5.479 -    VK_FORMAT_R64G64B64_SINT = 117,
   5.480 -    VK_FORMAT_R64G64B64_SFLOAT = 118,
   5.481 -    VK_FORMAT_R64G64B64A64_UINT = 119,
   5.482 -    VK_FORMAT_R64G64B64A64_SINT = 120,
   5.483 -    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
   5.484 -    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
   5.485 -    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
   5.486 -    VK_FORMAT_D16_UNORM = 124,
   5.487 -    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
   5.488 -    VK_FORMAT_D32_SFLOAT = 126,
   5.489 -    VK_FORMAT_S8_UINT = 127,
   5.490 -    VK_FORMAT_D16_UNORM_S8_UINT = 128,
   5.491 -    VK_FORMAT_D24_UNORM_S8_UINT = 129,
   5.492 -    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
   5.493 -    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
   5.494 -    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
   5.495 -    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
   5.496 -    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
   5.497 -    VK_FORMAT_BC2_UNORM_BLOCK = 135,
   5.498 -    VK_FORMAT_BC2_SRGB_BLOCK = 136,
   5.499 -    VK_FORMAT_BC3_UNORM_BLOCK = 137,
   5.500 -    VK_FORMAT_BC3_SRGB_BLOCK = 138,
   5.501 -    VK_FORMAT_BC4_UNORM_BLOCK = 139,
   5.502 -    VK_FORMAT_BC4_SNORM_BLOCK = 140,
   5.503 -    VK_FORMAT_BC5_UNORM_BLOCK = 141,
   5.504 -    VK_FORMAT_BC5_SNORM_BLOCK = 142,
   5.505 -    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
   5.506 -    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
   5.507 -    VK_FORMAT_BC7_UNORM_BLOCK = 145,
   5.508 -    VK_FORMAT_BC7_SRGB_BLOCK = 146,
   5.509 -    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
   5.510 -    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
   5.511 -    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
   5.512 -    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
   5.513 -    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
   5.514 -    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
   5.515 -    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
   5.516 -    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
   5.517 -    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
   5.518 -    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
   5.519 -    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
   5.520 -    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
   5.521 -    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
   5.522 -    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
   5.523 -    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
   5.524 -    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
   5.525 -    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
   5.526 -    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
   5.527 -    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
   5.528 -    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
   5.529 -    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
   5.530 -    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
   5.531 -    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
   5.532 -    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
   5.533 -    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
   5.534 -    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
   5.535 -    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
   5.536 -    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
   5.537 -    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
   5.538 -    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
   5.539 -    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
   5.540 -    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
   5.541 -    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
   5.542 -    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
   5.543 -    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
   5.544 -    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
   5.545 -    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
   5.546 -    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
   5.547 -    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
   5.548 -    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
   5.549 -    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
   5.550 -    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
   5.551 -    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
   5.552 -    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
   5.553 -    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
   5.554 -    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
   5.555 -    VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
   5.556 -    VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
   5.557 -    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
   5.558 -    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
   5.559 -} VkFormat;
   5.560 -
   5.561 -typedef enum VkImageType {
   5.562 -    VK_IMAGE_TYPE_1D = 0,
   5.563 -    VK_IMAGE_TYPE_2D = 1,
   5.564 -    VK_IMAGE_TYPE_3D = 2,
   5.565 -    VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
   5.566 -    VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
   5.567 -    VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
   5.568 -    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.569 -} VkImageType;
   5.570 -
   5.571 -typedef enum VkImageTiling {
   5.572 -    VK_IMAGE_TILING_OPTIMAL = 0,
   5.573 -    VK_IMAGE_TILING_LINEAR = 1,
   5.574 -    VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
   5.575 -    VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
   5.576 -    VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
   5.577 -    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
   5.578 -} VkImageTiling;
   5.579 -
   5.580 -typedef enum VkPhysicalDeviceType {
   5.581 -    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
   5.582 -    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
   5.583 -    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
   5.584 -    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
   5.585 -    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
   5.586 -    VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
   5.587 -    VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
   5.588 -    VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
   5.589 -    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.590 -} VkPhysicalDeviceType;
   5.591 -
   5.592 -typedef enum VkQueryType {
   5.593 -    VK_QUERY_TYPE_OCCLUSION = 0,
   5.594 -    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
   5.595 -    VK_QUERY_TYPE_TIMESTAMP = 2,
   5.596 -    VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
   5.597 -    VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
   5.598 -    VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
   5.599 -    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.600 -} VkQueryType;
   5.601 -
   5.602 -typedef enum VkSharingMode {
   5.603 -    VK_SHARING_MODE_EXCLUSIVE = 0,
   5.604 -    VK_SHARING_MODE_CONCURRENT = 1,
   5.605 -    VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
   5.606 -    VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
   5.607 -    VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
   5.608 -    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
   5.609 -} VkSharingMode;
   5.610 -
   5.611 -typedef enum VkImageLayout {
   5.612 -    VK_IMAGE_LAYOUT_UNDEFINED = 0,
   5.613 -    VK_IMAGE_LAYOUT_GENERAL = 1,
   5.614 -    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
   5.615 -    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
   5.616 -    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
   5.617 -    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
   5.618 -    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
   5.619 -    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
   5.620 -    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
   5.621 -    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
   5.622 -    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
   5.623 -    VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
   5.624 -    VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
   5.625 -    VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
   5.626 -    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
   5.627 -} VkImageLayout;
   5.628 -
   5.629 -typedef enum VkImageViewType {
   5.630 -    VK_IMAGE_VIEW_TYPE_1D = 0,
   5.631 -    VK_IMAGE_VIEW_TYPE_2D = 1,
   5.632 -    VK_IMAGE_VIEW_TYPE_3D = 2,
   5.633 -    VK_IMAGE_VIEW_TYPE_CUBE = 3,
   5.634 -    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
   5.635 -    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
   5.636 -    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
   5.637 -    VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
   5.638 -    VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
   5.639 -    VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
   5.640 -    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.641 -} VkImageViewType;
   5.642 -
   5.643 -typedef enum VkComponentSwizzle {
   5.644 -    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
   5.645 -    VK_COMPONENT_SWIZZLE_ZERO = 1,
   5.646 -    VK_COMPONENT_SWIZZLE_ONE = 2,
   5.647 -    VK_COMPONENT_SWIZZLE_R = 3,
   5.648 -    VK_COMPONENT_SWIZZLE_G = 4,
   5.649 -    VK_COMPONENT_SWIZZLE_B = 5,
   5.650 -    VK_COMPONENT_SWIZZLE_A = 6,
   5.651 -    VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
   5.652 -    VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
   5.653 -    VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
   5.654 -    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
   5.655 -} VkComponentSwizzle;
   5.656 -
   5.657 -typedef enum VkVertexInputRate {
   5.658 -    VK_VERTEX_INPUT_RATE_VERTEX = 0,
   5.659 -    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
   5.660 -    VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
   5.661 -    VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
   5.662 -    VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
   5.663 -    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
   5.664 -} VkVertexInputRate;
   5.665 -
   5.666 -typedef enum VkPrimitiveTopology {
   5.667 -    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
   5.668 -    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
   5.669 -    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
   5.670 -    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
   5.671 -    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
   5.672 -    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
   5.673 -    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
   5.674 -    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
   5.675 -    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
   5.676 -    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
   5.677 -    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
   5.678 -    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
   5.679 -    VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
   5.680 -    VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
   5.681 -    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
   5.682 -} VkPrimitiveTopology;
   5.683 -
   5.684 -typedef enum VkPolygonMode {
   5.685 -    VK_POLYGON_MODE_FILL = 0,
   5.686 -    VK_POLYGON_MODE_LINE = 1,
   5.687 -    VK_POLYGON_MODE_POINT = 2,
   5.688 -    VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
   5.689 -    VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
   5.690 -    VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
   5.691 -    VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
   5.692 -    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
   5.693 -} VkPolygonMode;
   5.694 -
   5.695 -typedef enum VkFrontFace {
   5.696 -    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
   5.697 -    VK_FRONT_FACE_CLOCKWISE = 1,
   5.698 -    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
   5.699 -    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
   5.700 -    VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
   5.701 -    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
   5.702 -} VkFrontFace;
   5.703 -
   5.704 -typedef enum VkCompareOp {
   5.705 -    VK_COMPARE_OP_NEVER = 0,
   5.706 -    VK_COMPARE_OP_LESS = 1,
   5.707 -    VK_COMPARE_OP_EQUAL = 2,
   5.708 -    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
   5.709 -    VK_COMPARE_OP_GREATER = 4,
   5.710 -    VK_COMPARE_OP_NOT_EQUAL = 5,
   5.711 -    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
   5.712 -    VK_COMPARE_OP_ALWAYS = 7,
   5.713 -    VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
   5.714 -    VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
   5.715 -    VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
   5.716 -    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
   5.717 -} VkCompareOp;
   5.718 -
   5.719 -typedef enum VkStencilOp {
   5.720 -    VK_STENCIL_OP_KEEP = 0,
   5.721 -    VK_STENCIL_OP_ZERO = 1,
   5.722 -    VK_STENCIL_OP_REPLACE = 2,
   5.723 -    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
   5.724 -    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
   5.725 -    VK_STENCIL_OP_INVERT = 5,
   5.726 -    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
   5.727 -    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
   5.728 -    VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
   5.729 -    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
   5.730 -    VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
   5.731 -    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
   5.732 -} VkStencilOp;
   5.733 -
   5.734 -typedef enum VkLogicOp {
   5.735 -    VK_LOGIC_OP_CLEAR = 0,
   5.736 -    VK_LOGIC_OP_AND = 1,
   5.737 -    VK_LOGIC_OP_AND_REVERSE = 2,
   5.738 -    VK_LOGIC_OP_COPY = 3,
   5.739 -    VK_LOGIC_OP_AND_INVERTED = 4,
   5.740 -    VK_LOGIC_OP_NO_OP = 5,
   5.741 -    VK_LOGIC_OP_XOR = 6,
   5.742 -    VK_LOGIC_OP_OR = 7,
   5.743 -    VK_LOGIC_OP_NOR = 8,
   5.744 -    VK_LOGIC_OP_EQUIVALENT = 9,
   5.745 -    VK_LOGIC_OP_INVERT = 10,
   5.746 -    VK_LOGIC_OP_OR_REVERSE = 11,
   5.747 -    VK_LOGIC_OP_COPY_INVERTED = 12,
   5.748 -    VK_LOGIC_OP_OR_INVERTED = 13,
   5.749 -    VK_LOGIC_OP_NAND = 14,
   5.750 -    VK_LOGIC_OP_SET = 15,
   5.751 -    VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
   5.752 -    VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
   5.753 -    VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
   5.754 -    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
   5.755 -} VkLogicOp;
   5.756 -
   5.757 -typedef enum VkBlendFactor {
   5.758 -    VK_BLEND_FACTOR_ZERO = 0,
   5.759 -    VK_BLEND_FACTOR_ONE = 1,
   5.760 -    VK_BLEND_FACTOR_SRC_COLOR = 2,
   5.761 -    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
   5.762 -    VK_BLEND_FACTOR_DST_COLOR = 4,
   5.763 -    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
   5.764 -    VK_BLEND_FACTOR_SRC_ALPHA = 6,
   5.765 -    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
   5.766 -    VK_BLEND_FACTOR_DST_ALPHA = 8,
   5.767 -    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
   5.768 -    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
   5.769 -    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
   5.770 -    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
   5.771 -    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
   5.772 -    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
   5.773 -    VK_BLEND_FACTOR_SRC1_COLOR = 15,
   5.774 -    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
   5.775 -    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
   5.776 -    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
   5.777 -    VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
   5.778 -    VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
   5.779 -    VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
   5.780 -    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
   5.781 -} VkBlendFactor;
   5.782 -
   5.783 -typedef enum VkBlendOp {
   5.784 -    VK_BLEND_OP_ADD = 0,
   5.785 -    VK_BLEND_OP_SUBTRACT = 1,
   5.786 -    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
   5.787 -    VK_BLEND_OP_MIN = 3,
   5.788 -    VK_BLEND_OP_MAX = 4,
   5.789 -    VK_BLEND_OP_ZERO_EXT = 1000148000,
   5.790 -    VK_BLEND_OP_SRC_EXT = 1000148001,
   5.791 -    VK_BLEND_OP_DST_EXT = 1000148002,
   5.792 -    VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
   5.793 -    VK_BLEND_OP_DST_OVER_EXT = 1000148004,
   5.794 -    VK_BLEND_OP_SRC_IN_EXT = 1000148005,
   5.795 -    VK_BLEND_OP_DST_IN_EXT = 1000148006,
   5.796 -    VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
   5.797 -    VK_BLEND_OP_DST_OUT_EXT = 1000148008,
   5.798 -    VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
   5.799 -    VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
   5.800 -    VK_BLEND_OP_XOR_EXT = 1000148011,
   5.801 -    VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
   5.802 -    VK_BLEND_OP_SCREEN_EXT = 1000148013,
   5.803 -    VK_BLEND_OP_OVERLAY_EXT = 1000148014,
   5.804 -    VK_BLEND_OP_DARKEN_EXT = 1000148015,
   5.805 -    VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
   5.806 -    VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
   5.807 -    VK_BLEND_OP_COLORBURN_EXT = 1000148018,
   5.808 -    VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
   5.809 -    VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
   5.810 -    VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
   5.811 -    VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
   5.812 -    VK_BLEND_OP_INVERT_EXT = 1000148023,
   5.813 -    VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
   5.814 -    VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
   5.815 -    VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
   5.816 -    VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
   5.817 -    VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
   5.818 -    VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
   5.819 -    VK_BLEND_OP_HARDMIX_EXT = 1000148030,
   5.820 -    VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
   5.821 -    VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
   5.822 -    VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
   5.823 -    VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
   5.824 -    VK_BLEND_OP_PLUS_EXT = 1000148035,
   5.825 -    VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
   5.826 -    VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
   5.827 -    VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
   5.828 -    VK_BLEND_OP_MINUS_EXT = 1000148039,
   5.829 -    VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
   5.830 -    VK_BLEND_OP_CONTRAST_EXT = 1000148041,
   5.831 -    VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
   5.832 -    VK_BLEND_OP_RED_EXT = 1000148043,
   5.833 -    VK_BLEND_OP_GREEN_EXT = 1000148044,
   5.834 -    VK_BLEND_OP_BLUE_EXT = 1000148045,
   5.835 -    VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
   5.836 -    VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
   5.837 -    VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
   5.838 -    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
   5.839 -} VkBlendOp;
   5.840 -
   5.841 -typedef enum VkDynamicState {
   5.842 -    VK_DYNAMIC_STATE_VIEWPORT = 0,
   5.843 -    VK_DYNAMIC_STATE_SCISSOR = 1,
   5.844 -    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
   5.845 -    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
   5.846 -    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
   5.847 -    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
   5.848 -    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
   5.849 -    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
   5.850 -    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
   5.851 -    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
   5.852 -    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
   5.853 -    VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
   5.854 -    VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
   5.855 -    VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
   5.856 -    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
   5.857 -} VkDynamicState;
   5.858 -
   5.859 -typedef enum VkFilter {
   5.860 -    VK_FILTER_NEAREST = 0,
   5.861 -    VK_FILTER_LINEAR = 1,
   5.862 -    VK_FILTER_CUBIC_IMG = 1000015000,
   5.863 -    VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
   5.864 -    VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
   5.865 -    VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
   5.866 -    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
   5.867 -} VkFilter;
   5.868 -
   5.869 -typedef enum VkSamplerMipmapMode {
   5.870 -    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
   5.871 -    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
   5.872 -    VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
   5.873 -    VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
   5.874 -    VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
   5.875 -    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
   5.876 -} VkSamplerMipmapMode;
   5.877 -
   5.878 -typedef enum VkSamplerAddressMode {
   5.879 -    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
   5.880 -    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
   5.881 -    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
   5.882 -    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
   5.883 -    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
   5.884 -    VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
   5.885 -    VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
   5.886 -    VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
   5.887 -    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
   5.888 -} VkSamplerAddressMode;
   5.889 -
   5.890 -typedef enum VkBorderColor {
   5.891 -    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
   5.892 -    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
   5.893 -    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
   5.894 -    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
   5.895 -    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
   5.896 -    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
   5.897 -    VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
   5.898 -    VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
   5.899 -    VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
   5.900 -    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
   5.901 -} VkBorderColor;
   5.902 -
   5.903 -typedef enum VkDescriptorType {
   5.904 -    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
   5.905 -    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
   5.906 -    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
   5.907 -    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
   5.908 -    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
   5.909 -    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
   5.910 -    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
   5.911 -    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
   5.912 -    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
   5.913 -    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
   5.914 -    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
   5.915 -    VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
   5.916 -    VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
   5.917 -    VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
   5.918 -    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.919 -} VkDescriptorType;
   5.920 -
   5.921 -typedef enum VkAttachmentLoadOp {
   5.922 -    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
   5.923 -    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
   5.924 -    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
   5.925 -    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
   5.926 -    VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   5.927 -    VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
   5.928 -    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
   5.929 -} VkAttachmentLoadOp;
   5.930 -
   5.931 -typedef enum VkAttachmentStoreOp {
   5.932 -    VK_ATTACHMENT_STORE_OP_STORE = 0,
   5.933 -    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
   5.934 -    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
   5.935 -    VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
   5.936 -    VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
   5.937 -    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
   5.938 -} VkAttachmentStoreOp;
   5.939 -
   5.940 -typedef enum VkPipelineBindPoint {
   5.941 -    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
   5.942 -    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
   5.943 -    VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
   5.944 -    VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
   5.945 -    VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
   5.946 -    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
   5.947 -} VkPipelineBindPoint;
   5.948 -
   5.949 -typedef enum VkCommandBufferLevel {
   5.950 -    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
   5.951 -    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
   5.952 -    VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
   5.953 -    VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
   5.954 -    VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
   5.955 -    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
   5.956 -} VkCommandBufferLevel;
   5.957 -
   5.958 -typedef enum VkIndexType {
   5.959 -    VK_INDEX_TYPE_UINT16 = 0,
   5.960 -    VK_INDEX_TYPE_UINT32 = 1,
   5.961 -    VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
   5.962 -    VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
   5.963 -    VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
   5.964 -    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
   5.965 -} VkIndexType;
   5.966 -
   5.967 -typedef enum VkSubpassContents {
   5.968 -    VK_SUBPASS_CONTENTS_INLINE = 0,
   5.969 -    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
   5.970 -    VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
   5.971 -    VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
   5.972 -    VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
   5.973 -    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
   5.974 -} VkSubpassContents;
   5.975 -
   5.976 -typedef enum VkObjectType {
   5.977 -    VK_OBJECT_TYPE_UNKNOWN = 0,
   5.978 -    VK_OBJECT_TYPE_INSTANCE = 1,
   5.979 -    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
   5.980 -    VK_OBJECT_TYPE_DEVICE = 3,
   5.981 -    VK_OBJECT_TYPE_QUEUE = 4,
   5.982 -    VK_OBJECT_TYPE_SEMAPHORE = 5,
   5.983 -    VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
   5.984 -    VK_OBJECT_TYPE_FENCE = 7,
   5.985 -    VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
   5.986 -    VK_OBJECT_TYPE_BUFFER = 9,
   5.987 -    VK_OBJECT_TYPE_IMAGE = 10,
   5.988 -    VK_OBJECT_TYPE_EVENT = 11,
   5.989 -    VK_OBJECT_TYPE_QUERY_POOL = 12,
   5.990 -    VK_OBJECT_TYPE_BUFFER_VIEW = 13,
   5.991 -    VK_OBJECT_TYPE_IMAGE_VIEW = 14,
   5.992 -    VK_OBJECT_TYPE_SHADER_MODULE = 15,
   5.993 -    VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
   5.994 -    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
   5.995 -    VK_OBJECT_TYPE_RENDER_PASS = 18,
   5.996 -    VK_OBJECT_TYPE_PIPELINE = 19,
   5.997 -    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
   5.998 -    VK_OBJECT_TYPE_SAMPLER = 21,
   5.999 -    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
  5.1000 -    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
  5.1001 -    VK_OBJECT_TYPE_FRAMEBUFFER = 24,
  5.1002 -    VK_OBJECT_TYPE_COMMAND_POOL = 25,
  5.1003 -    VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
  5.1004 -    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
  5.1005 -    VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
  5.1006 -    VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
  5.1007 -    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
  5.1008 -    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000,
  5.1009 -    VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
  5.1010 -    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
  5.1011 -    VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
  5.1012 -    VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
  5.1013 -    VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
  5.1014 -    VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
  5.1015 -} VkObjectType;
  5.1016 -
  5.1017 -typedef VkFlags VkInstanceCreateFlags;
  5.1018 -
  5.1019 -typedef enum VkFormatFeatureFlagBits {
  5.1020 -    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
  5.1021 -    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
  5.1022 -    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
  5.1023 -    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
  5.1024 -    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
  5.1025 -    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
  5.1026 -    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
  5.1027 -    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
  5.1028 -    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
  5.1029 -    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
  5.1030 -    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
  5.1031 -    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
  5.1032 -    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
  5.1033 -    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
  5.1034 -    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
  5.1035 -    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
  5.1036 -    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
  5.1037 -    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1038 -} VkFormatFeatureFlagBits;
  5.1039 -typedef VkFlags VkFormatFeatureFlags;
  5.1040 -
  5.1041 -typedef enum VkImageUsageFlagBits {
  5.1042 -    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
  5.1043 -    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
  5.1044 -    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
  5.1045 -    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
  5.1046 -    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
  5.1047 -    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
  5.1048 -    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
  5.1049 -    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
  5.1050 -    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1051 -} VkImageUsageFlagBits;
  5.1052 -typedef VkFlags VkImageUsageFlags;
  5.1053 -
  5.1054 -typedef enum VkImageCreateFlagBits {
  5.1055 -    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
  5.1056 -    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
  5.1057 -    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
  5.1058 -    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
  5.1059 -    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
  5.1060 -    VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
  5.1061 -    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
  5.1062 -    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1063 -} VkImageCreateFlagBits;
  5.1064 -typedef VkFlags VkImageCreateFlags;
  5.1065 -
  5.1066 -typedef enum VkSampleCountFlagBits {
  5.1067 -    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
  5.1068 -    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
  5.1069 -    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
  5.1070 -    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
  5.1071 -    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
  5.1072 -    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
  5.1073 -    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
  5.1074 -    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1075 -} VkSampleCountFlagBits;
  5.1076 -typedef VkFlags VkSampleCountFlags;
  5.1077 -
  5.1078 -typedef enum VkQueueFlagBits {
  5.1079 -    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
  5.1080 -    VK_QUEUE_COMPUTE_BIT = 0x00000002,
  5.1081 -    VK_QUEUE_TRANSFER_BIT = 0x00000004,
  5.1082 -    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
  5.1083 -    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1084 -} VkQueueFlagBits;
  5.1085 -typedef VkFlags VkQueueFlags;
  5.1086 -
  5.1087 -typedef enum VkMemoryPropertyFlagBits {
  5.1088 -    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
  5.1089 -    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
  5.1090 -    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
  5.1091 -    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
  5.1092 -    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
  5.1093 -    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1094 -} VkMemoryPropertyFlagBits;
  5.1095 -typedef VkFlags VkMemoryPropertyFlags;
  5.1096 -
  5.1097 -typedef enum VkMemoryHeapFlagBits {
  5.1098 -    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
  5.1099 -    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
  5.1100 -    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1101 -} VkMemoryHeapFlagBits;
  5.1102 -typedef VkFlags VkMemoryHeapFlags;
  5.1103 -typedef VkFlags VkDeviceCreateFlags;
  5.1104 -typedef VkFlags VkDeviceQueueCreateFlags;
  5.1105 -
  5.1106 -typedef enum VkPipelineStageFlagBits {
  5.1107 -    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
  5.1108 -    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
  5.1109 -    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
  5.1110 -    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
  5.1111 -    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
  5.1112 -    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
  5.1113 -    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
  5.1114 -    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
  5.1115 -    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
  5.1116 -    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
  5.1117 -    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
  5.1118 -    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
  5.1119 -    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
  5.1120 -    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
  5.1121 -    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
  5.1122 -    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
  5.1123 -    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
  5.1124 -    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
  5.1125 -    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1126 -} VkPipelineStageFlagBits;
  5.1127 -typedef VkFlags VkPipelineStageFlags;
  5.1128 -typedef VkFlags VkMemoryMapFlags;
  5.1129 -
  5.1130 -typedef enum VkImageAspectFlagBits {
  5.1131 -    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
  5.1132 -    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
  5.1133 -    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
  5.1134 -    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
  5.1135 -    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1136 -} VkImageAspectFlagBits;
  5.1137 -typedef VkFlags VkImageAspectFlags;
  5.1138 -
  5.1139 -typedef enum VkSparseImageFormatFlagBits {
  5.1140 -    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
  5.1141 -    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
  5.1142 -    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
  5.1143 -    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1144 -} VkSparseImageFormatFlagBits;
  5.1145 -typedef VkFlags VkSparseImageFormatFlags;
  5.1146 -
  5.1147 -typedef enum VkSparseMemoryBindFlagBits {
  5.1148 -    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
  5.1149 -    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1150 -} VkSparseMemoryBindFlagBits;
  5.1151 -typedef VkFlags VkSparseMemoryBindFlags;
  5.1152 -
  5.1153 -typedef enum VkFenceCreateFlagBits {
  5.1154 -    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
  5.1155 -    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1156 -} VkFenceCreateFlagBits;
  5.1157 -typedef VkFlags VkFenceCreateFlags;
  5.1158 -typedef VkFlags VkSemaphoreCreateFlags;
  5.1159 -typedef VkFlags VkEventCreateFlags;
  5.1160 -typedef VkFlags VkQueryPoolCreateFlags;
  5.1161 -
  5.1162 -typedef enum VkQueryPipelineStatisticFlagBits {
  5.1163 -    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
  5.1164 -    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
  5.1165 -    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
  5.1166 -    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
  5.1167 -    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
  5.1168 -    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
  5.1169 -    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
  5.1170 -    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
  5.1171 -    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
  5.1172 -    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
  5.1173 -    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
  5.1174 -    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1175 -} VkQueryPipelineStatisticFlagBits;
  5.1176 -typedef VkFlags VkQueryPipelineStatisticFlags;
  5.1177 -
  5.1178 -typedef enum VkQueryResultFlagBits {
  5.1179 -    VK_QUERY_RESULT_64_BIT = 0x00000001,
  5.1180 -    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
  5.1181 -    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
  5.1182 -    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
  5.1183 -    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1184 -} VkQueryResultFlagBits;
  5.1185 -typedef VkFlags VkQueryResultFlags;
  5.1186 -
  5.1187 -typedef enum VkBufferCreateFlagBits {
  5.1188 -    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
  5.1189 -    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
  5.1190 -    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
  5.1191 -    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1192 -} VkBufferCreateFlagBits;
  5.1193 -typedef VkFlags VkBufferCreateFlags;
  5.1194 -
  5.1195 -typedef enum VkBufferUsageFlagBits {
  5.1196 -    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
  5.1197 -    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
  5.1198 -    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
  5.1199 -    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
  5.1200 -    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
  5.1201 -    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
  5.1202 -    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
  5.1203 -    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
  5.1204 -    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
  5.1205 -    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1206 -} VkBufferUsageFlagBits;
  5.1207 -typedef VkFlags VkBufferUsageFlags;
  5.1208 -typedef VkFlags VkBufferViewCreateFlags;
  5.1209 -typedef VkFlags VkImageViewCreateFlags;
  5.1210 -typedef VkFlags VkShaderModuleCreateFlags;
  5.1211 -typedef VkFlags VkPipelineCacheCreateFlags;
  5.1212 -
  5.1213 -typedef enum VkPipelineCreateFlagBits {
  5.1214 -    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
  5.1215 -    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
  5.1216 -    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
  5.1217 -    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
  5.1218 -    VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
  5.1219 -    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1220 -} VkPipelineCreateFlagBits;
  5.1221 -typedef VkFlags VkPipelineCreateFlags;
  5.1222 -typedef VkFlags VkPipelineShaderStageCreateFlags;
  5.1223 -
  5.1224 -typedef enum VkShaderStageFlagBits {
  5.1225 -    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
  5.1226 -    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
  5.1227 -    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
  5.1228 -    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
  5.1229 -    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
  5.1230 -    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
  5.1231 -    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
  5.1232 -    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
  5.1233 -    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1234 -} VkShaderStageFlagBits;
  5.1235 -typedef VkFlags VkPipelineVertexInputStateCreateFlags;
  5.1236 -typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
  5.1237 -typedef VkFlags VkPipelineTessellationStateCreateFlags;
  5.1238 -typedef VkFlags VkPipelineViewportStateCreateFlags;
  5.1239 -typedef VkFlags VkPipelineRasterizationStateCreateFlags;
  5.1240 -
  5.1241 -typedef enum VkCullModeFlagBits {
  5.1242 -    VK_CULL_MODE_NONE = 0,
  5.1243 -    VK_CULL_MODE_FRONT_BIT = 0x00000001,
  5.1244 -    VK_CULL_MODE_BACK_BIT = 0x00000002,
  5.1245 -    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
  5.1246 -    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1247 -} VkCullModeFlagBits;
  5.1248 -typedef VkFlags VkCullModeFlags;
  5.1249 -typedef VkFlags VkPipelineMultisampleStateCreateFlags;
  5.1250 -typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
  5.1251 -typedef VkFlags VkPipelineColorBlendStateCreateFlags;
  5.1252 -
  5.1253 -typedef enum VkColorComponentFlagBits {
  5.1254 -    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
  5.1255 -    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
  5.1256 -    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
  5.1257 -    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
  5.1258 -    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1259 -} VkColorComponentFlagBits;
  5.1260 -typedef VkFlags VkColorComponentFlags;
  5.1261 -typedef VkFlags VkPipelineDynamicStateCreateFlags;
  5.1262 -typedef VkFlags VkPipelineLayoutCreateFlags;
  5.1263 -typedef VkFlags VkShaderStageFlags;
  5.1264 -typedef VkFlags VkSamplerCreateFlags;
  5.1265 -
  5.1266 -typedef enum VkDescriptorSetLayoutCreateFlagBits {
  5.1267 -    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
  5.1268 -    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1269 -} VkDescriptorSetLayoutCreateFlagBits;
  5.1270 -typedef VkFlags VkDescriptorSetLayoutCreateFlags;
  5.1271 -
  5.1272 -typedef enum VkDescriptorPoolCreateFlagBits {
  5.1273 -    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
  5.1274 -    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1275 -} VkDescriptorPoolCreateFlagBits;
  5.1276 -typedef VkFlags VkDescriptorPoolCreateFlags;
  5.1277 -typedef VkFlags VkDescriptorPoolResetFlags;
  5.1278 -typedef VkFlags VkFramebufferCreateFlags;
  5.1279 -typedef VkFlags VkRenderPassCreateFlags;
  5.1280 -
  5.1281 -typedef enum VkAttachmentDescriptionFlagBits {
  5.1282 -    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
  5.1283 -    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1284 -} VkAttachmentDescriptionFlagBits;
  5.1285 -typedef VkFlags VkAttachmentDescriptionFlags;
  5.1286 -
  5.1287 -typedef enum VkSubpassDescriptionFlagBits {
  5.1288 -    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
  5.1289 -    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
  5.1290 -    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1291 -} VkSubpassDescriptionFlagBits;
  5.1292 -typedef VkFlags VkSubpassDescriptionFlags;
  5.1293 -
  5.1294 -typedef enum VkAccessFlagBits {
  5.1295 -    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
  5.1296 -    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
  5.1297 -    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
  5.1298 -    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
  5.1299 -    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
  5.1300 -    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
  5.1301 -    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
  5.1302 -    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
  5.1303 -    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
  5.1304 -    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
  5.1305 -    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
  5.1306 -    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
  5.1307 -    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
  5.1308 -    VK_ACCESS_HOST_READ_BIT = 0x00002000,
  5.1309 -    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
  5.1310 -    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
  5.1311 -    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
  5.1312 -    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
  5.1313 -    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
  5.1314 -    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
  5.1315 -    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1316 -} VkAccessFlagBits;
  5.1317 -typedef VkFlags VkAccessFlags;
  5.1318 -
  5.1319 -typedef enum VkDependencyFlagBits {
  5.1320 -    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
  5.1321 -    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
  5.1322 -    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
  5.1323 -    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1324 -} VkDependencyFlagBits;
  5.1325 -typedef VkFlags VkDependencyFlags;
  5.1326 -
  5.1327 -typedef enum VkCommandPoolCreateFlagBits {
  5.1328 -    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
  5.1329 -    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
  5.1330 -    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1331 -} VkCommandPoolCreateFlagBits;
  5.1332 -typedef VkFlags VkCommandPoolCreateFlags;
  5.1333 -
  5.1334 -typedef enum VkCommandPoolResetFlagBits {
  5.1335 -    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
  5.1336 -    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1337 -} VkCommandPoolResetFlagBits;
  5.1338 -typedef VkFlags VkCommandPoolResetFlags;
  5.1339 -
  5.1340 -typedef enum VkCommandBufferUsageFlagBits {
  5.1341 -    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
  5.1342 -    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
  5.1343 -    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
  5.1344 -    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1345 -} VkCommandBufferUsageFlagBits;
  5.1346 -typedef VkFlags VkCommandBufferUsageFlags;
  5.1347 -
  5.1348 -typedef enum VkQueryControlFlagBits {
  5.1349 -    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
  5.1350 -    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1351 -} VkQueryControlFlagBits;
  5.1352 -typedef VkFlags VkQueryControlFlags;
  5.1353 -
  5.1354 -typedef enum VkCommandBufferResetFlagBits {
  5.1355 -    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
  5.1356 -    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1357 -} VkCommandBufferResetFlagBits;
  5.1358 -typedef VkFlags VkCommandBufferResetFlags;
  5.1359 -
  5.1360 -typedef enum VkStencilFaceFlagBits {
  5.1361 -    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
  5.1362 -    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
  5.1363 -    VK_STENCIL_FRONT_AND_BACK = 0x00000003,
  5.1364 -    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  5.1365 -} VkStencilFaceFlagBits;
  5.1366 -typedef VkFlags VkStencilFaceFlags;
  5.1367 -
  5.1368 -typedef struct VkApplicationInfo {
  5.1369 -    VkStructureType    sType;
  5.1370 -    const void*        pNext;
  5.1371 -    const char*        pApplicationName;
  5.1372 -    uint32_t           applicationVersion;
  5.1373 -    const char*        pEngineName;
  5.1374 -    uint32_t           engineVersion;
  5.1375 -    uint32_t           apiVersion;
  5.1376 -} VkApplicationInfo;
  5.1377 -
  5.1378 -typedef struct VkInstanceCreateInfo {
  5.1379 -    VkStructureType             sType;
  5.1380 -    const void*                 pNext;
  5.1381 -    VkInstanceCreateFlags       flags;
  5.1382 -    const VkApplicationInfo*    pApplicationInfo;
  5.1383 -    uint32_t                    enabledLayerCount;
  5.1384 -    const char* const*          ppEnabledLayerNames;
  5.1385 -    uint32_t                    enabledExtensionCount;
  5.1386 -    const char* const*          ppEnabledExtensionNames;
  5.1387 -} VkInstanceCreateInfo;
  5.1388 -
  5.1389 -typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
  5.1390 -    void*                                       pUserData,
  5.1391 -    size_t                                      size,
  5.1392 -    size_t                                      alignment,
  5.1393 -    VkSystemAllocationScope                     allocationScope);
  5.1394 -
  5.1395 -typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
  5.1396 -    void*                                       pUserData,
  5.1397 -    void*                                       pOriginal,
  5.1398 -    size_t                                      size,
  5.1399 -    size_t                                      alignment,
  5.1400 -    VkSystemAllocationScope                     allocationScope);
  5.1401 -
  5.1402 -typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
  5.1403 -    void*                                       pUserData,
  5.1404 -    void*                                       pMemory);
  5.1405 -
  5.1406 -typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
  5.1407 -    void*                                       pUserData,
  5.1408 -    size_t                                      size,
  5.1409 -    VkInternalAllocationType                    allocationType,
  5.1410 -    VkSystemAllocationScope                     allocationScope);
  5.1411 -
  5.1412 -typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
  5.1413 -    void*                                       pUserData,
  5.1414 -    size_t                                      size,
  5.1415 -    VkInternalAllocationType                    allocationType,
  5.1416 -    VkSystemAllocationScope                     allocationScope);
  5.1417 -
  5.1418 -typedef struct VkAllocationCallbacks {
  5.1419 -    void*                                   pUserData;
  5.1420 -    PFN_vkAllocationFunction                pfnAllocation;
  5.1421 -    PFN_vkReallocationFunction              pfnReallocation;
  5.1422 -    PFN_vkFreeFunction                      pfnFree;
  5.1423 -    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
  5.1424 -    PFN_vkInternalFreeNotification          pfnInternalFree;
  5.1425 -} VkAllocationCallbacks;
  5.1426 -
  5.1427 -typedef struct VkPhysicalDeviceFeatures {
  5.1428 -    VkBool32    robustBufferAccess;
  5.1429 -    VkBool32    fullDrawIndexUint32;
  5.1430 -    VkBool32    imageCubeArray;
  5.1431 -    VkBool32    independentBlend;
  5.1432 -    VkBool32    geometryShader;
  5.1433 -    VkBool32    tessellationShader;
  5.1434 -    VkBool32    sampleRateShading;
  5.1435 -    VkBool32    dualSrcBlend;
  5.1436 -    VkBool32    logicOp;
  5.1437 -    VkBool32    multiDrawIndirect;
  5.1438 -    VkBool32    drawIndirectFirstInstance;
  5.1439 -    VkBool32    depthClamp;
  5.1440 -    VkBool32    depthBiasClamp;
  5.1441 -    VkBool32    fillModeNonSolid;
  5.1442 -    VkBool32    depthBounds;
  5.1443 -    VkBool32    wideLines;
  5.1444 -    VkBool32    largePoints;
  5.1445 -    VkBool32    alphaToOne;
  5.1446 -    VkBool32    multiViewport;
  5.1447 -    VkBool32    samplerAnisotropy;
  5.1448 -    VkBool32    textureCompressionETC2;
  5.1449 -    VkBool32    textureCompressionASTC_LDR;
  5.1450 -    VkBool32    textureCompressionBC;
  5.1451 -    VkBool32    occlusionQueryPrecise;
  5.1452 -    VkBool32    pipelineStatisticsQuery;
  5.1453 -    VkBool32    vertexPipelineStoresAndAtomics;
  5.1454 -    VkBool32    fragmentStoresAndAtomics;
  5.1455 -    VkBool32    shaderTessellationAndGeometryPointSize;
  5.1456 -    VkBool32    shaderImageGatherExtended;
  5.1457 -    VkBool32    shaderStorageImageExtendedFormats;
  5.1458 -    VkBool32    shaderStorageImageMultisample;
  5.1459 -    VkBool32    shaderStorageImageReadWithoutFormat;
  5.1460 -    VkBool32    shaderStorageImageWriteWithoutFormat;
  5.1461 -    VkBool32    shaderUniformBufferArrayDynamicIndexing;
  5.1462 -    VkBool32    shaderSampledImageArrayDynamicIndexing;
  5.1463 -    VkBool32    shaderStorageBufferArrayDynamicIndexing;
  5.1464 -    VkBool32    shaderStorageImageArrayDynamicIndexing;
  5.1465 -    VkBool32    shaderClipDistance;
  5.1466 -    VkBool32    shaderCullDistance;
  5.1467 -    VkBool32    shaderFloat64;
  5.1468 -    VkBool32    shaderInt64;
  5.1469 -    VkBool32    shaderInt16;
  5.1470 -    VkBool32    shaderResourceResidency;
  5.1471 -    VkBool32    shaderResourceMinLod;
  5.1472 -    VkBool32    sparseBinding;
  5.1473 -    VkBool32    sparseResidencyBuffer;
  5.1474 -    VkBool32    sparseResidencyImage2D;
  5.1475 -    VkBool32    sparseResidencyImage3D;
  5.1476 -    VkBool32    sparseResidency2Samples;
  5.1477 -    VkBool32    sparseResidency4Samples;
  5.1478 -    VkBool32    sparseResidency8Samples;
  5.1479 -    VkBool32    sparseResidency16Samples;
  5.1480 -    VkBool32    sparseResidencyAliased;
  5.1481 -    VkBool32    variableMultisampleRate;
  5.1482 -    VkBool32    inheritedQueries;
  5.1483 -} VkPhysicalDeviceFeatures;
  5.1484 -
  5.1485 -typedef struct VkFormatProperties {
  5.1486 -    VkFormatFeatureFlags    linearTilingFeatures;
  5.1487 -    VkFormatFeatureFlags    optimalTilingFeatures;
  5.1488 -    VkFormatFeatureFlags    bufferFeatures;
  5.1489 -} VkFormatProperties;
  5.1490 -
  5.1491 -typedef struct VkExtent3D {
  5.1492 -    uint32_t    width;
  5.1493 -    uint32_t    height;
  5.1494 -    uint32_t    depth;
  5.1495 -} VkExtent3D;
  5.1496 -
  5.1497 -typedef struct VkImageFormatProperties {
  5.1498 -    VkExtent3D            maxExtent;
  5.1499 -    uint32_t              maxMipLevels;
  5.1500 -    uint32_t              maxArrayLayers;
  5.1501 -    VkSampleCountFlags    sampleCounts;
  5.1502 -    VkDeviceSize          maxResourceSize;
  5.1503 -} VkImageFormatProperties;
  5.1504 -
  5.1505 -typedef struct VkPhysicalDeviceLimits {
  5.1506 -    uint32_t              maxImageDimension1D;
  5.1507 -    uint32_t              maxImageDimension2D;
  5.1508 -    uint32_t              maxImageDimension3D;
  5.1509 -    uint32_t              maxImageDimensionCube;
  5.1510 -    uint32_t              maxImageArrayLayers;
  5.1511 -    uint32_t              maxTexelBufferElements;
  5.1512 -    uint32_t              maxUniformBufferRange;
  5.1513 -    uint32_t              maxStorageBufferRange;
  5.1514 -    uint32_t              maxPushConstantsSize;
  5.1515 -    uint32_t              maxMemoryAllocationCount;
  5.1516 -    uint32_t              maxSamplerAllocationCount;
  5.1517 -    VkDeviceSize          bufferImageGranularity;
  5.1518 -    VkDeviceSize          sparseAddressSpaceSize;
  5.1519 -    uint32_t              maxBoundDescriptorSets;
  5.1520 -    uint32_t              maxPerStageDescriptorSamplers;
  5.1521 -    uint32_t              maxPerStageDescriptorUniformBuffers;
  5.1522 -    uint32_t              maxPerStageDescriptorStorageBuffers;
  5.1523 -    uint32_t              maxPerStageDescriptorSampledImages;
  5.1524 -    uint32_t              maxPerStageDescriptorStorageImages;
  5.1525 -    uint32_t              maxPerStageDescriptorInputAttachments;
  5.1526 -    uint32_t              maxPerStageResources;
  5.1527 -    uint32_t              maxDescriptorSetSamplers;
  5.1528 -    uint32_t              maxDescriptorSetUniformBuffers;
  5.1529 -    uint32_t              maxDescriptorSetUniformBuffersDynamic;
  5.1530 -    uint32_t              maxDescriptorSetStorageBuffers;
  5.1531 -    uint32_t              maxDescriptorSetStorageBuffersDynamic;
  5.1532 -    uint32_t              maxDescriptorSetSampledImages;
  5.1533 -    uint32_t              maxDescriptorSetStorageImages;
  5.1534 -    uint32_t              maxDescriptorSetInputAttachments;
  5.1535 -    uint32_t              maxVertexInputAttributes;
  5.1536 -    uint32_t              maxVertexInputBindings;
  5.1537 -    uint32_t              maxVertexInputAttributeOffset;
  5.1538 -    uint32_t              maxVertexInputBindingStride;
  5.1539 -    uint32_t              maxVertexOutputComponents;
  5.1540 -    uint32_t              maxTessellationGenerationLevel;
  5.1541 -    uint32_t              maxTessellationPatchSize;
  5.1542 -    uint32_t              maxTessellationControlPerVertexInputComponents;
  5.1543 -    uint32_t              maxTessellationControlPerVertexOutputComponents;
  5.1544 -    uint32_t              maxTessellationControlPerPatchOutputComponents;
  5.1545 -    uint32_t              maxTessellationControlTotalOutputComponents;
  5.1546 -    uint32_t              maxTessellationEvaluationInputComponents;
  5.1547 -    uint32_t              maxTessellationEvaluationOutputComponents;
  5.1548 -    uint32_t              maxGeometryShaderInvocations;
  5.1549 -    uint32_t              maxGeometryInputComponents;
  5.1550 -    uint32_t              maxGeometryOutputComponents;
  5.1551 -    uint32_t              maxGeometryOutputVertices;
  5.1552 -    uint32_t              maxGeometryTotalOutputComponents;
  5.1553 -    uint32_t              maxFragmentInputComponents;
  5.1554 -    uint32_t              maxFragmentOutputAttachments;
  5.1555 -    uint32_t              maxFragmentDualSrcAttachments;
  5.1556 -    uint32_t              maxFragmentCombinedOutputResources;
  5.1557 -    uint32_t              maxComputeSharedMemorySize;
  5.1558 -    uint32_t              maxComputeWorkGroupCount[3];
  5.1559 -    uint32_t              maxComputeWorkGroupInvocations;
  5.1560 -    uint32_t              maxComputeWorkGroupSize[3];
  5.1561 -    uint32_t              subPixelPrecisionBits;
  5.1562 -    uint32_t              subTexelPrecisionBits;
  5.1563 -    uint32_t              mipmapPrecisionBits;
  5.1564 -    uint32_t              maxDrawIndexedIndexValue;
  5.1565 -    uint32_t              maxDrawIndirectCount;
  5.1566 -    float                 maxSamplerLodBias;
  5.1567 -    float                 maxSamplerAnisotropy;
  5.1568 -    uint32_t              maxViewports;
  5.1569 -    uint32_t              maxViewportDimensions[2];
  5.1570 -    float                 viewportBoundsRange[2];
  5.1571 -    uint32_t              viewportSubPixelBits;
  5.1572 -    size_t                minMemoryMapAlignment;
  5.1573 -    VkDeviceSize          minTexelBufferOffsetAlignment;
  5.1574 -    VkDeviceSize          minUniformBufferOffsetAlignment;
  5.1575 -    VkDeviceSize          minStorageBufferOffsetAlignment;
  5.1576 -    int32_t               minTexelOffset;
  5.1577 -    uint32_t              maxTexelOffset;
  5.1578 -    int32_t               minTexelGatherOffset;
  5.1579 -    uint32_t              maxTexelGatherOffset;
  5.1580 -    float                 minInterpolationOffset;
  5.1581 -    float                 maxInterpolationOffset;
  5.1582 -    uint32_t              subPixelInterpolationOffsetBits;
  5.1583 -    uint32_t              maxFramebufferWidth;
  5.1584 -    uint32_t              maxFramebufferHeight;
  5.1585 -    uint32_t              maxFramebufferLayers;
  5.1586 -    VkSampleCountFlags    framebufferColorSampleCounts;
  5.1587 -    VkSampleCountFlags    framebufferDepthSampleCounts;
  5.1588 -    VkSampleCountFlags    framebufferStencilSampleCounts;
  5.1589 -    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
  5.1590 -    uint32_t              maxColorAttachments;
  5.1591 -    VkSampleCountFlags    sampledImageColorSampleCounts;
  5.1592 -    VkSampleCountFlags    sampledImageIntegerSampleCounts;
  5.1593 -    VkSampleCountFlags    sampledImageDepthSampleCounts;
  5.1594 -    VkSampleCountFlags    sampledImageStencilSampleCounts;
  5.1595 -    VkSampleCountFlags    storageImageSampleCounts;
  5.1596 -    uint32_t              maxSampleMaskWords;
  5.1597 -    VkBool32              timestampComputeAndGraphics;
  5.1598 -    float                 timestampPeriod;
  5.1599 -    uint32_t              maxClipDistances;
  5.1600 -    uint32_t              maxCullDistances;
  5.1601 -    uint32_t              maxCombinedClipAndCullDistances;
  5.1602 -    uint32_t              discreteQueuePriorities;
  5.1603 -    float                 pointSizeRange[2];
  5.1604 -    float                 lineWidthRange[2];
  5.1605 -    float                 pointSizeGranularity;
  5.1606 -    float                 lineWidthGranularity;
  5.1607 -    VkBool32              strictLines;
  5.1608 -    VkBool32              standardSampleLocations;
  5.1609 -    VkDeviceSize          optimalBufferCopyOffsetAlignment;
  5.1610 -    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
  5.1611 -    VkDeviceSize          nonCoherentAtomSize;
  5.1612 -} VkPhysicalDeviceLimits;
  5.1613 -
  5.1614 -typedef struct VkPhysicalDeviceSparseProperties {
  5.1615 -    VkBool32    residencyStandard2DBlockShape;
  5.1616 -    VkBool32    residencyStandard2DMultisampleBlockShape;
  5.1617 -    VkBool32    residencyStandard3DBlockShape;
  5.1618 -    VkBool32    residencyAlignedMipSize;
  5.1619 -    VkBool32    residencyNonResidentStrict;
  5.1620 -} VkPhysicalDeviceSparseProperties;
  5.1621 -
  5.1622 -typedef struct VkPhysicalDeviceProperties {
  5.1623 -    uint32_t                            apiVersion;
  5.1624 -    uint32_t                            driverVersion;
  5.1625 -    uint32_t                            vendorID;
  5.1626 -    uint32_t                            deviceID;
  5.1627 -    VkPhysicalDeviceType                deviceType;
  5.1628 -    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
  5.1629 -    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
  5.1630 -    VkPhysicalDeviceLimits              limits;
  5.1631 -    VkPhysicalDeviceSparseProperties    sparseProperties;
  5.1632 -} VkPhysicalDeviceProperties;
  5.1633 -
  5.1634 -typedef struct VkQueueFamilyProperties {
  5.1635 -    VkQueueFlags    queueFlags;
  5.1636 -    uint32_t        queueCount;
  5.1637 -    uint32_t        timestampValidBits;
  5.1638 -    VkExtent3D      minImageTransferGranularity;
  5.1639 -} VkQueueFamilyProperties;
  5.1640 -
  5.1641 -typedef struct VkMemoryType {
  5.1642 -    VkMemoryPropertyFlags    propertyFlags;
  5.1643 -    uint32_t                 heapIndex;
  5.1644 -} VkMemoryType;
  5.1645 -
  5.1646 -typedef struct VkMemoryHeap {
  5.1647 -    VkDeviceSize         size;
  5.1648 -    VkMemoryHeapFlags    flags;
  5.1649 -} VkMemoryHeap;
  5.1650 -
  5.1651 -typedef struct VkPhysicalDeviceMemoryProperties {
  5.1652 -    uint32_t        memoryTypeCount;
  5.1653 -    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
  5.1654 -    uint32_t        memoryHeapCount;
  5.1655 -    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
  5.1656 -} VkPhysicalDeviceMemoryProperties;
  5.1657 -
  5.1658 -typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
  5.1659 -typedef struct VkDeviceQueueCreateInfo {
  5.1660 -    VkStructureType             sType;
  5.1661 -    const void*                 pNext;
  5.1662 -    VkDeviceQueueCreateFlags    flags;
  5.1663 -    uint32_t                    queueFamilyIndex;
  5.1664 -    uint32_t                    queueCount;
  5.1665 -    const float*                pQueuePriorities;
  5.1666 -} VkDeviceQueueCreateInfo;
  5.1667 -
  5.1668 -typedef struct VkDeviceCreateInfo {
  5.1669 -    VkStructureType                    sType;
  5.1670 -    const void*                        pNext;
  5.1671 -    VkDeviceCreateFlags                flags;
  5.1672 -    uint32_t                           queueCreateInfoCount;
  5.1673 -    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
  5.1674 -    uint32_t                           enabledLayerCount;
  5.1675 -    const char* const*                 ppEnabledLayerNames;
  5.1676 -    uint32_t                           enabledExtensionCount;
  5.1677 -    const char* const*                 ppEnabledExtensionNames;
  5.1678 -    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
  5.1679 -} VkDeviceCreateInfo;
  5.1680 -
  5.1681 -typedef struct VkExtensionProperties {
  5.1682 -    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
  5.1683 -    uint32_t    specVersion;
  5.1684 -} VkExtensionProperties;
  5.1685 -
  5.1686 -typedef struct VkLayerProperties {
  5.1687 -    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
  5.1688 -    uint32_t    specVersion;
  5.1689 -    uint32_t    implementationVersion;
  5.1690 -    char        description[VK_MAX_DESCRIPTION_SIZE];
  5.1691 -} VkLayerProperties;
  5.1692 -
  5.1693 -typedef struct VkSubmitInfo {
  5.1694 -    VkStructureType                sType;
  5.1695 -    const void*                    pNext;
  5.1696 -    uint32_t                       waitSemaphoreCount;
  5.1697 -    const VkSemaphore*             pWaitSemaphores;
  5.1698 -    const VkPipelineStageFlags*    pWaitDstStageMask;
  5.1699 -    uint32_t                       commandBufferCount;
  5.1700 -    const VkCommandBuffer*         pCommandBuffers;
  5.1701 -    uint32_t                       signalSemaphoreCount;
  5.1702 -    const VkSemaphore*             pSignalSemaphores;
  5.1703 -} VkSubmitInfo;
  5.1704 -
  5.1705 -typedef struct VkMemoryAllocateInfo {
  5.1706 -    VkStructureType    sType;
  5.1707 -    const void*        pNext;
  5.1708 -    VkDeviceSize       allocationSize;
  5.1709 -    uint32_t           memoryTypeIndex;
  5.1710 -} VkMemoryAllocateInfo;
  5.1711 -
  5.1712 -typedef struct VkMappedMemoryRange {
  5.1713 -    VkStructureType    sType;
  5.1714 -    const void*        pNext;
  5.1715 -    VkDeviceMemory     memory;
  5.1716 -    VkDeviceSize       offset;
  5.1717 -    VkDeviceSize       size;
  5.1718 -} VkMappedMemoryRange;
  5.1719 -
  5.1720 -typedef struct VkMemoryRequirements {
  5.1721 -    VkDeviceSize    size;
  5.1722 -    VkDeviceSize    alignment;
  5.1723 -    uint32_t        memoryTypeBits;
  5.1724 -} VkMemoryRequirements;
  5.1725 -
  5.1726 -typedef struct VkSparseImageFormatProperties {
  5.1727 -    VkImageAspectFlags          aspectMask;
  5.1728 -    VkExtent3D                  imageGranularity;
  5.1729 -    VkSparseImageFormatFlags    flags;
  5.1730 -} VkSparseImageFormatProperties;
  5.1731 -
  5.1732 -typedef struct VkSparseImageMemoryRequirements {
  5.1733 -    VkSparseImageFormatProperties    formatProperties;
  5.1734 -    uint32_t                         imageMipTailFirstLod;
  5.1735 -    VkDeviceSize                     imageMipTailSize;
  5.1736 -    VkDeviceSize                     imageMipTailOffset;
  5.1737 -    VkDeviceSize                     imageMipTailStride;
  5.1738 -} VkSparseImageMemoryRequirements;
  5.1739 -
  5.1740 -typedef struct VkSparseMemoryBind {
  5.1741 -    VkDeviceSize               resourceOffset;
  5.1742 -    VkDeviceSize               size;
  5.1743 -    VkDeviceMemory             memory;
  5.1744 -    VkDeviceSize               memoryOffset;
  5.1745 -    VkSparseMemoryBindFlags    flags;
  5.1746 -} VkSparseMemoryBind;
  5.1747 -
  5.1748 -typedef struct VkSparseBufferMemoryBindInfo {
  5.1749 -    VkBuffer                     buffer;
  5.1750 -    uint32_t                     bindCount;
  5.1751 -    const VkSparseMemoryBind*    pBinds;
  5.1752 -} VkSparseBufferMemoryBindInfo;
  5.1753 -
  5.1754 -typedef struct VkSparseImageOpaqueMemoryBindInfo {
  5.1755 -    VkImage                      image;
  5.1756 -    uint32_t                     bindCount;
  5.1757 -    const VkSparseMemoryBind*    pBinds;
  5.1758 -} VkSparseImageOpaqueMemoryBindInfo;
  5.1759 -
  5.1760 -typedef struct VkImageSubresource {
  5.1761 -    VkImageAspectFlags    aspectMask;
  5.1762 -    uint32_t              mipLevel;
  5.1763 -    uint32_t              arrayLayer;
  5.1764 -} VkImageSubresource;
  5.1765 -
  5.1766 -typedef struct VkOffset3D {
  5.1767 -    int32_t    x;
  5.1768 -    int32_t    y;
  5.1769 -    int32_t    z;
  5.1770 -} VkOffset3D;
  5.1771 -
  5.1772 -typedef struct VkSparseImageMemoryBind {
  5.1773 -    VkImageSubresource         subresource;
  5.1774 -    VkOffset3D                 offset;
  5.1775 -    VkExtent3D                 extent;
  5.1776 -    VkDeviceMemory             memory;
  5.1777 -    VkDeviceSize               memoryOffset;
  5.1778 -    VkSparseMemoryBindFlags    flags;
  5.1779 -} VkSparseImageMemoryBind;
  5.1780 -
  5.1781 -typedef struct VkSparseImageMemoryBindInfo {
  5.1782 -    VkImage                           image;
  5.1783 -    uint32_t                          bindCount;
  5.1784 -    const VkSparseImageMemoryBind*    pBinds;
  5.1785 -} VkSparseImageMemoryBindInfo;
  5.1786 -
  5.1787 -typedef struct VkBindSparseInfo {
  5.1788 -    VkStructureType                             sType;
  5.1789 -    const void*                                 pNext;
  5.1790 -    uint32_t                                    waitSemaphoreCount;
  5.1791 -    const VkSemaphore*                          pWaitSemaphores;
  5.1792 -    uint32_t                                    bufferBindCount;
  5.1793 -    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
  5.1794 -    uint32_t                                    imageOpaqueBindCount;
  5.1795 -    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
  5.1796 -    uint32_t                                    imageBindCount;
  5.1797 -    const VkSparseImageMemoryBindInfo*          pImageBinds;
  5.1798 -    uint32_t                                    signalSemaphoreCount;
  5.1799 -    const VkSemaphore*                          pSignalSemaphores;
  5.1800 -} VkBindSparseInfo;
  5.1801 -
  5.1802 -typedef struct VkFenceCreateInfo {
  5.1803 -    VkStructureType       sType;
  5.1804 -    const void*           pNext;
  5.1805 -    VkFenceCreateFlags    flags;
  5.1806 -} VkFenceCreateInfo;
  5.1807 -
  5.1808 -typedef struct VkSemaphoreCreateInfo {
  5.1809 -    VkStructureType           sType;
  5.1810 -    const void*               pNext;
  5.1811 -    VkSemaphoreCreateFlags    flags;
  5.1812 -} VkSemaphoreCreateInfo;
  5.1813 -
  5.1814 -typedef struct VkEventCreateInfo {
  5.1815 -    VkStructureType       sType;
  5.1816 -    const void*           pNext;
  5.1817 -    VkEventCreateFlags    flags;
  5.1818 -} VkEventCreateInfo;
  5.1819 -
  5.1820 -typedef struct VkQueryPoolCreateInfo {
  5.1821 -    VkStructureType                  sType;
  5.1822 -    const void*                      pNext;
  5.1823 -    VkQueryPoolCreateFlags           flags;
  5.1824 -    VkQueryType                      queryType;
  5.1825 -    uint32_t                         queryCount;
  5.1826 -    VkQueryPipelineStatisticFlags    pipelineStatistics;
  5.1827 -} VkQueryPoolCreateInfo;
  5.1828 -
  5.1829 -typedef struct VkBufferCreateInfo {
  5.1830 -    VkStructureType        sType;
  5.1831 -    const void*            pNext;
  5.1832 -    VkBufferCreateFlags    flags;
  5.1833 -    VkDeviceSize           size;
  5.1834 -    VkBufferUsageFlags     usage;
  5.1835 -    VkSharingMode          sharingMode;
  5.1836 -    uint32_t               queueFamilyIndexCount;
  5.1837 -    const uint32_t*        pQueueFamilyIndices;
  5.1838 -} VkBufferCreateInfo;
  5.1839 -
  5.1840 -typedef struct VkBufferViewCreateInfo {
  5.1841 -    VkStructureType            sType;
  5.1842 -    const void*                pNext;
  5.1843 -    VkBufferViewCreateFlags    flags;
  5.1844 -    VkBuffer                   buffer;
  5.1845 -    VkFormat                   format;
  5.1846 -    VkDeviceSize               offset;
  5.1847 -    VkDeviceSize               range;
  5.1848 -} VkBufferViewCreateInfo;
  5.1849 -
  5.1850 -typedef struct VkImageCreateInfo {
  5.1851 -    VkStructureType          sType;
  5.1852 -    const void*              pNext;
  5.1853 -    VkImageCreateFlags       flags;
  5.1854 -    VkImageType              imageType;
  5.1855 -    VkFormat                 format;
  5.1856 -    VkExtent3D               extent;
  5.1857 -    uint32_t                 mipLevels;
  5.1858 -    uint32_t                 arrayLayers;
  5.1859 -    VkSampleCountFlagBits    samples;
  5.1860 -    VkImageTiling            tiling;
  5.1861 -    VkImageUsageFlags        usage;
  5.1862 -    VkSharingMode            sharingMode;
  5.1863 -    uint32_t                 queueFamilyIndexCount;
  5.1864 -    const uint32_t*          pQueueFamilyIndices;
  5.1865 -    VkImageLayout            initialLayout;
  5.1866 -} VkImageCreateInfo;
  5.1867 -
  5.1868 -typedef struct VkSubresourceLayout {
  5.1869 -    VkDeviceSize    offset;
  5.1870 -    VkDeviceSize    size;
  5.1871 -    VkDeviceSize    rowPitch;
  5.1872 -    VkDeviceSize    arrayPitch;
  5.1873 -    VkDeviceSize    depthPitch;
  5.1874 -} VkSubresourceLayout;
  5.1875 -
  5.1876 -typedef struct VkComponentMapping {
  5.1877 -    VkComponentSwizzle    r;
  5.1878 -    VkComponentSwizzle    g;
  5.1879 -    VkComponentSwizzle    b;
  5.1880 -    VkComponentSwizzle    a;
  5.1881 -} VkComponentMapping;
  5.1882 -
  5.1883 -typedef struct VkImageSubresourceRange {
  5.1884 -    VkImageAspectFlags    aspectMask;
  5.1885 -    uint32_t              baseMipLevel;
  5.1886 -    uint32_t              levelCount;
  5.1887 -    uint32_t              baseArrayLayer;
  5.1888 -    uint32_t              layerCount;
  5.1889 -} VkImageSubresourceRange;
  5.1890 -
  5.1891 -typedef struct VkImageViewCreateInfo {
  5.1892 -    VkStructureType            sType;
  5.1893 -    const void*                pNext;
  5.1894 -    VkImageViewCreateFlags     flags;
  5.1895 -    VkImage                    image;
  5.1896 -    VkImageViewType            viewType;
  5.1897 -    VkFormat                   format;
  5.1898 -    VkComponentMapping         components;
  5.1899 -    VkImageSubresourceRange    subresourceRange;
  5.1900 -} VkImageViewCreateInfo;
  5.1901 -
  5.1902 -typedef struct VkShaderModuleCreateInfo {
  5.1903 -    VkStructureType              sType;
  5.1904 -    const void*                  pNext;
  5.1905 -    VkShaderModuleCreateFlags    flags;
  5.1906 -    size_t                       codeSize;
  5.1907 -    const uint32_t*              pCode;
  5.1908 -} VkShaderModuleCreateInfo;
  5.1909 -
  5.1910 -typedef struct VkPipelineCacheCreateInfo {
  5.1911 -    VkStructureType               sType;
  5.1912 -    const void*                   pNext;
  5.1913 -    VkPipelineCacheCreateFlags    flags;
  5.1914 -    size_t                        initialDataSize;
  5.1915 -    const void*                   pInitialData;
  5.1916 -} VkPipelineCacheCreateInfo;
  5.1917 -
  5.1918 -typedef struct VkSpecializationMapEntry {
  5.1919 -    uint32_t    constantID;
  5.1920 -    uint32_t    offset;
  5.1921 -    size_t      size;
  5.1922 -} VkSpecializationMapEntry;
  5.1923 -
  5.1924 -typedef struct VkSpecializationInfo {
  5.1925 -    uint32_t                           mapEntryCount;
  5.1926 -    const VkSpecializationMapEntry*    pMapEntries;
  5.1927 -    size_t                             dataSize;
  5.1928 -    const void*                        pData;
  5.1929 -} VkSpecializationInfo;
  5.1930 -
  5.1931 -typedef struct VkPipelineShaderStageCreateInfo {
  5.1932 -    VkStructureType                     sType;
  5.1933 -    const void*                         pNext;
  5.1934 -    VkPipelineShaderStageCreateFlags    flags;
  5.1935 -    VkShaderStageFlagBits               stage;
  5.1936 -    VkShaderModule                      module;
  5.1937 -    const char*                         pName;
  5.1938 -    const VkSpecializationInfo*         pSpecializationInfo;
  5.1939 -} VkPipelineShaderStageCreateInfo;
  5.1940 -
  5.1941 -typedef struct VkVertexInputBindingDescription {
  5.1942 -    uint32_t             binding;
  5.1943 -    uint32_t             stride;
  5.1944 -    VkVertexInputRate    inputRate;
  5.1945 -} VkVertexInputBindingDescription;
  5.1946 -
  5.1947 -typedef struct VkVertexInputAttributeDescription {
  5.1948 -    uint32_t    location;
  5.1949 -    uint32_t    binding;
  5.1950 -    VkFormat    format;
  5.1951 -    uint32_t    offset;
  5.1952 -} VkVertexInputAttributeDescription;
  5.1953 -
  5.1954 -typedef struct VkPipelineVertexInputStateCreateInfo {
  5.1955 -    VkStructureType                             sType;
  5.1956 -    const void*                                 pNext;
  5.1957 -    VkPipelineVertexInputStateCreateFlags       flags;
  5.1958 -    uint32_t                                    vertexBindingDescriptionCount;
  5.1959 -    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
  5.1960 -    uint32_t                                    vertexAttributeDescriptionCount;
  5.1961 -    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
  5.1962 -} VkPipelineVertexInputStateCreateInfo;
  5.1963 -
  5.1964 -typedef struct VkPipelineInputAssemblyStateCreateInfo {
  5.1965 -    VkStructureType                            sType;
  5.1966 -    const void*                                pNext;
  5.1967 -    VkPipelineInputAssemblyStateCreateFlags    flags;
  5.1968 -    VkPrimitiveTopology                        topology;
  5.1969 -    VkBool32                                   primitiveRestartEnable;
  5.1970 -} VkPipelineInputAssemblyStateCreateInfo;
  5.1971 -
  5.1972 -typedef struct VkPipelineTessellationStateCreateInfo {
  5.1973 -    VkStructureType                           sType;
  5.1974 -    const void*                               pNext;
  5.1975 -    VkPipelineTessellationStateCreateFlags    flags;
  5.1976 -    uint32_t                                  patchControlPoints;
  5.1977 -} VkPipelineTessellationStateCreateInfo;
  5.1978 -
  5.1979 -typedef struct VkViewport {
  5.1980 -    float    x;
  5.1981 -    float    y;
  5.1982 -    float    width;
  5.1983 -    float    height;
  5.1984 -    float    minDepth;
  5.1985 -    float    maxDepth;
  5.1986 -} VkViewport;
  5.1987 -
  5.1988 -typedef struct VkOffset2D {
  5.1989 -    int32_t    x;
  5.1990 -    int32_t    y;
  5.1991 -} VkOffset2D;
  5.1992 -
  5.1993 -typedef struct VkExtent2D {
  5.1994 -    uint32_t    width;
  5.1995 -    uint32_t    height;
  5.1996 -} VkExtent2D;
  5.1997 -
  5.1998 -typedef struct VkRect2D {
  5.1999 -    VkOffset2D    offset;
  5.2000 -    VkExtent2D    extent;
  5.2001 -} VkRect2D;
  5.2002 -
  5.2003 -typedef struct VkPipelineViewportStateCreateInfo {
  5.2004 -    VkStructureType                       sType;
  5.2005 -    const void*                           pNext;
  5.2006 -    VkPipelineViewportStateCreateFlags    flags;
  5.2007 -    uint32_t                              viewportCount;
  5.2008 -    const VkViewport*                     pViewports;
  5.2009 -    uint32_t                              scissorCount;
  5.2010 -    const VkRect2D*                       pScissors;
  5.2011 -} VkPipelineViewportStateCreateInfo;
  5.2012 -
  5.2013 -typedef struct VkPipelineRasterizationStateCreateInfo {
  5.2014 -    VkStructureType                            sType;
  5.2015 -    const void*                                pNext;
  5.2016 -    VkPipelineRasterizationStateCreateFlags    flags;
  5.2017 -    VkBool32                                   depthClampEnable;
  5.2018 -    VkBool32                                   rasterizerDiscardEnable;
  5.2019 -    VkPolygonMode                              polygonMode;
  5.2020 -    VkCullModeFlags                            cullMode;
  5.2021 -    VkFrontFace                                frontFace;
  5.2022 -    VkBool32                                   depthBiasEnable;
  5.2023 -    float                                      depthBiasConstantFactor;
  5.2024 -    float                                      depthBiasClamp;
  5.2025 -    float                                      depthBiasSlopeFactor;
  5.2026 -    float                                      lineWidth;
  5.2027 -} VkPipelineRasterizationStateCreateInfo;
  5.2028 -
  5.2029 -typedef struct VkPipelineMultisampleStateCreateInfo {
  5.2030 -    VkStructureType                          sType;
  5.2031 -    const void*                              pNext;
  5.2032 -    VkPipelineMultisampleStateCreateFlags    flags;
  5.2033 -    VkSampleCountFlagBits                    rasterizationSamples;
  5.2034 -    VkBool32                                 sampleShadingEnable;
  5.2035 -    float                                    minSampleShading;
  5.2036 -    const VkSampleMask*                      pSampleMask;
  5.2037 -    VkBool32                                 alphaToCoverageEnable;
  5.2038 -    VkBool32                                 alphaToOneEnable;
  5.2039 -} VkPipelineMultisampleStateCreateInfo;
  5.2040 -
  5.2041 -typedef struct VkStencilOpState {
  5.2042 -    VkStencilOp    failOp;
  5.2043 -    VkStencilOp    passOp;
  5.2044 -    VkStencilOp    depthFailOp;
  5.2045 -    VkCompareOp    compareOp;
  5.2046 -    uint32_t       compareMask;
  5.2047 -    uint32_t       writeMask;
  5.2048 -    uint32_t       reference;
  5.2049 -} VkStencilOpState;
  5.2050 -
  5.2051 -typedef struct VkPipelineDepthStencilStateCreateInfo {
  5.2052 -    VkStructureType                           sType;
  5.2053 -    const void*                               pNext;
  5.2054 -    VkPipelineDepthStencilStateCreateFlags    flags;
  5.2055 -    VkBool32                                  depthTestEnable;
  5.2056 -    VkBool32                                  depthWriteEnable;
  5.2057 -    VkCompareOp                               depthCompareOp;
  5.2058 -    VkBool32                                  depthBoundsTestEnable;
  5.2059 -    VkBool32                                  stencilTestEnable;
  5.2060 -    VkStencilOpState                          front;
  5.2061 -    VkStencilOpState                          back;
  5.2062 -    float                                     minDepthBounds;
  5.2063 -    float                                     maxDepthBounds;
  5.2064 -} VkPipelineDepthStencilStateCreateInfo;
  5.2065 -
  5.2066 -typedef struct VkPipelineColorBlendAttachmentState {
  5.2067 -    VkBool32                 blendEnable;
  5.2068 -    VkBlendFactor            srcColorBlendFactor;
  5.2069 -    VkBlendFactor            dstColorBlendFactor;
  5.2070 -    VkBlendOp                colorBlendOp;
  5.2071 -    VkBlendFactor            srcAlphaBlendFactor;
  5.2072 -    VkBlendFactor            dstAlphaBlendFactor;
  5.2073 -    VkBlendOp                alphaBlendOp;
  5.2074 -    VkColorComponentFlags    colorWriteMask;
  5.2075 -} VkPipelineColorBlendAttachmentState;
  5.2076 -
  5.2077 -typedef struct VkPipelineColorBlendStateCreateInfo {
  5.2078 -    VkStructureType                               sType;
  5.2079 -    const void*                                   pNext;
  5.2080 -    VkPipelineColorBlendStateCreateFlags          flags;
  5.2081 -    VkBool32                                      logicOpEnable;
  5.2082 -    VkLogicOp                                     logicOp;
  5.2083 -    uint32_t                                      attachmentCount;
  5.2084 -    const VkPipelineColorBlendAttachmentState*    pAttachments;
  5.2085 -    float                                         blendConstants[4];
  5.2086 -} VkPipelineColorBlendStateCreateInfo;
  5.2087 -
  5.2088 -typedef struct VkPipelineDynamicStateCreateInfo {
  5.2089 -    VkStructureType                      sType;
  5.2090 -    const void*                          pNext;
  5.2091 -    VkPipelineDynamicStateCreateFlags    flags;
  5.2092 -    uint32_t                             dynamicStateCount;
  5.2093 -    const VkDynamicState*                pDynamicStates;
  5.2094 -} VkPipelineDynamicStateCreateInfo;
  5.2095 -
  5.2096 -typedef struct VkGraphicsPipelineCreateInfo {
  5.2097 -    VkStructureType                                  sType;
  5.2098 -    const void*                                      pNext;
  5.2099 -    VkPipelineCreateFlags                            flags;
  5.2100 -    uint32_t                                         stageCount;
  5.2101 -    const VkPipelineShaderStageCreateInfo*           pStages;
  5.2102 -    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
  5.2103 -    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
  5.2104 -    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
  5.2105 -    const VkPipelineViewportStateCreateInfo*         pViewportState;
  5.2106 -    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
  5.2107 -    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
  5.2108 -    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
  5.2109 -    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
  5.2110 -    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
  5.2111 -    VkPipelineLayout                                 layout;
  5.2112 -    VkRenderPass                                     renderPass;
  5.2113 -    uint32_t                                         subpass;
  5.2114 -    VkPipeline                                       basePipelineHandle;
  5.2115 -    int32_t                                          basePipelineIndex;
  5.2116 -} VkGraphicsPipelineCreateInfo;
  5.2117 -
  5.2118 -typedef struct VkComputePipelineCreateInfo {
  5.2119 -    VkStructureType                    sType;
  5.2120 -    const void*                        pNext;
  5.2121 -    VkPipelineCreateFlags              flags;
  5.2122 -    VkPipelineShaderStageCreateInfo    stage;
  5.2123 -    VkPipelineLayout                   layout;
  5.2124 -    VkPipeline                         basePipelineHandle;
  5.2125 -    int32_t                            basePipelineIndex;
  5.2126 -} VkComputePipelineCreateInfo;
  5.2127 -
  5.2128 -typedef struct VkPushConstantRange {
  5.2129 -    VkShaderStageFlags    stageFlags;
  5.2130 -    uint32_t              offset;
  5.2131 -    uint32_t              size;
  5.2132 -} VkPushConstantRange;
  5.2133 -
  5.2134 -typedef struct VkPipelineLayoutCreateInfo {
  5.2135 -    VkStructureType                 sType;
  5.2136 -    const void*                     pNext;
  5.2137 -    VkPipelineLayoutCreateFlags     flags;
  5.2138 -    uint32_t                        setLayoutCount;
  5.2139 -    const VkDescriptorSetLayout*    pSetLayouts;
  5.2140 -    uint32_t                        pushConstantRangeCount;
  5.2141 -    const VkPushConstantRange*      pPushConstantRanges;
  5.2142 -} VkPipelineLayoutCreateInfo;
  5.2143 -
  5.2144 -typedef struct VkSamplerCreateInfo {
  5.2145 -    VkStructureType         sType;
  5.2146 -    const void*             pNext;
  5.2147 -    VkSamplerCreateFlags    flags;
  5.2148 -    VkFilter                magFilter;
  5.2149 -    VkFilter                minFilter;
  5.2150 -    VkSamplerMipmapMode     mipmapMode;
  5.2151 -    VkSamplerAddressMode    addressModeU;
  5.2152 -    VkSamplerAddressMode    addressModeV;
  5.2153 -    VkSamplerAddressMode    addressModeW;
  5.2154 -    float                   mipLodBias;
  5.2155 -    VkBool32                anisotropyEnable;
  5.2156 -    float                   maxAnisotropy;
  5.2157 -    VkBool32                compareEnable;
  5.2158 -    VkCompareOp             compareOp;
  5.2159 -    float                   minLod;
  5.2160 -    float                   maxLod;
  5.2161 -    VkBorderColor           borderColor;
  5.2162 -    VkBool32                unnormalizedCoordinates;
  5.2163 -} VkSamplerCreateInfo;
  5.2164 -
  5.2165 -typedef struct VkDescriptorSetLayoutBinding {
  5.2166 -    uint32_t              binding;
  5.2167 -    VkDescriptorType      descriptorType;
  5.2168 -    uint32_t              descriptorCount;
  5.2169 -    VkShaderStageFlags    stageFlags;
  5.2170 -    const VkSampler*      pImmutableSamplers;
  5.2171 -} VkDescriptorSetLayoutBinding;
  5.2172 -
  5.2173 -typedef struct VkDescriptorSetLayoutCreateInfo {
  5.2174 -    VkStructureType                        sType;
  5.2175 -    const void*                            pNext;
  5.2176 -    VkDescriptorSetLayoutCreateFlags       flags;
  5.2177 -    uint32_t                               bindingCount;
  5.2178 -    const VkDescriptorSetLayoutBinding*    pBindings;
  5.2179 -} VkDescriptorSetLayoutCreateInfo;
  5.2180 -
  5.2181 -typedef struct VkDescriptorPoolSize {
  5.2182 -    VkDescriptorType    type;
  5.2183 -    uint32_t            descriptorCount;
  5.2184 -} VkDescriptorPoolSize;
  5.2185 -
  5.2186 -typedef struct VkDescriptorPoolCreateInfo {
  5.2187 -    VkStructureType                sType;
  5.2188 -    const void*                    pNext;
  5.2189 -    VkDescriptorPoolCreateFlags    flags;
  5.2190 -    uint32_t                       maxSets;
  5.2191 -    uint32_t                       poolSizeCount;
  5.2192 -    const VkDescriptorPoolSize*    pPoolSizes;
  5.2193 -} VkDescriptorPoolCreateInfo;
  5.2194 -
  5.2195 -typedef struct VkDescriptorSetAllocateInfo {
  5.2196 -    VkStructureType                 sType;
  5.2197 -    const void*                     pNext;
  5.2198 -    VkDescriptorPool                descriptorPool;
  5.2199 -    uint32_t                        descriptorSetCount;
  5.2200 -    const VkDescriptorSetLayout*    pSetLayouts;
  5.2201 -} VkDescriptorSetAllocateInfo;
  5.2202 -
  5.2203 -typedef struct VkDescriptorImageInfo {
  5.2204 -    VkSampler        sampler;
  5.2205 -    VkImageView      imageView;
  5.2206 -    VkImageLayout    imageLayout;
  5.2207 -} VkDescriptorImageInfo;
  5.2208 -
  5.2209 -typedef struct VkDescriptorBufferInfo {
  5.2210 -    VkBuffer        buffer;
  5.2211 -    VkDeviceSize    offset;
  5.2212 -    VkDeviceSize    range;
  5.2213 -} VkDescriptorBufferInfo;
  5.2214 -
  5.2215 -typedef struct VkWriteDescriptorSet {
  5.2216 -    VkStructureType                  sType;
  5.2217 -    const void*                      pNext;
  5.2218 -    VkDescriptorSet                  dstSet;
  5.2219 -    uint32_t                         dstBinding;
  5.2220 -    uint32_t                         dstArrayElement;
  5.2221 -    uint32_t                         descriptorCount;
  5.2222 -    VkDescriptorType                 descriptorType;
  5.2223 -    const VkDescriptorImageInfo*     pImageInfo;
  5.2224 -    const VkDescriptorBufferInfo*    pBufferInfo;
  5.2225 -    const VkBufferView*              pTexelBufferView;
  5.2226 -} VkWriteDescriptorSet;
  5.2227 -
  5.2228 -typedef struct VkCopyDescriptorSet {
  5.2229 -    VkStructureType    sType;
  5.2230 -    const void*        pNext;
  5.2231 -    VkDescriptorSet    srcSet;
  5.2232 -    uint32_t           srcBinding;
  5.2233 -    uint32_t           srcArrayElement;
  5.2234 -    VkDescriptorSet    dstSet;
  5.2235 -    uint32_t           dstBinding;
  5.2236 -    uint32_t           dstArrayElement;
  5.2237 -    uint32_t           descriptorCount;
  5.2238 -} VkCopyDescriptorSet;
  5.2239 -
  5.2240 -typedef struct VkFramebufferCreateInfo {
  5.2241 -    VkStructureType             sType;
  5.2242 -    const void*                 pNext;
  5.2243 -    VkFramebufferCreateFlags    flags;
  5.2244 -    VkRenderPass                renderPass;
  5.2245 -    uint32_t                    attachmentCount;
  5.2246 -    const VkImageView*          pAttachments;
  5.2247 -    uint32_t                    width;
  5.2248 -    uint32_t                    height;
  5.2249 -    uint32_t                    layers;
  5.2250 -} VkFramebufferCreateInfo;
  5.2251 -
  5.2252 -typedef struct VkAttachmentDescription {
  5.2253 -    VkAttachmentDescriptionFlags    flags;
  5.2254 -    VkFormat                        format;
  5.2255 -    VkSampleCountFlagBits           samples;
  5.2256 -    VkAttachmentLoadOp              loadOp;
  5.2257 -    VkAttachmentStoreOp             storeOp;
  5.2258 -    VkAttachmentLoadOp              stencilLoadOp;
  5.2259 -    VkAttachmentStoreOp             stencilStoreOp;
  5.2260 -    VkImageLayout                   initialLayout;
  5.2261 -    VkImageLayout                   finalLayout;
  5.2262 -} VkAttachmentDescription;
  5.2263 -
  5.2264 -typedef struct VkAttachmentReference {
  5.2265 -    uint32_t         attachment;
  5.2266 -    VkImageLayout    layout;
  5.2267 -} VkAttachmentReference;
  5.2268 -
  5.2269 -typedef struct VkSubpassDescription {
  5.2270 -    VkSubpassDescriptionFlags       flags;
  5.2271 -    VkPipelineBindPoint             pipelineBindPoint;
  5.2272 -    uint32_t                        inputAttachmentCount;
  5.2273 -    const VkAttachmentReference*    pInputAttachments;
  5.2274 -    uint32_t                        colorAttachmentCount;
  5.2275 -    const VkAttachmentReference*    pColorAttachments;
  5.2276 -    const VkAttachmentReference*    pResolveAttachments;
  5.2277 -    const VkAttachmentReference*    pDepthStencilAttachment;
  5.2278 -    uint32_t                        preserveAttachmentCount;
  5.2279 -    const uint32_t*                 pPreserveAttachments;
  5.2280 -} VkSubpassDescription;
  5.2281 -
  5.2282 -typedef struct VkSubpassDependency {
  5.2283 -    uint32_t                srcSubpass;
  5.2284 -    uint32_t                dstSubpass;
  5.2285 -    VkPipelineStageFlags    srcStageMask;
  5.2286 -    VkPipelineStageFlags    dstStageMask;
  5.2287 -    VkAccessFlags           srcAccessMask;
  5.2288 -    VkAccessFlags           dstAccessMask;
  5.2289 -    VkDependencyFlags       dependencyFlags;
  5.2290 -} VkSubpassDependency;
  5.2291 -
  5.2292 -typedef struct VkRenderPassCreateInfo {
  5.2293 -    VkStructureType                   sType;
  5.2294 -    const void*                       pNext;
  5.2295 -    VkRenderPassCreateFlags           flags;
  5.2296 -    uint32_t                          attachmentCount;
  5.2297 -    const VkAttachmentDescription*    pAttachments;
  5.2298 -    uint32_t                          subpassCount;
  5.2299 -    const VkSubpassDescription*       pSubpasses;
  5.2300 -    uint32_t                          dependencyCount;
  5.2301 -    const VkSubpassDependency*        pDependencies;
  5.2302 -} VkRenderPassCreateInfo;
  5.2303 -
  5.2304 -typedef struct VkCommandPoolCreateInfo {
  5.2305 -    VkStructureType             sType;
  5.2306 -    const void*                 pNext;
  5.2307 -    VkCommandPoolCreateFlags    flags;
  5.2308 -    uint32_t                    queueFamilyIndex;
  5.2309 -} VkCommandPoolCreateInfo;
  5.2310 -
  5.2311 -typedef struct VkCommandBufferAllocateInfo {
  5.2312 -    VkStructureType         sType;
  5.2313 -    const void*             pNext;
  5.2314 -    VkCommandPool           commandPool;
  5.2315 -    VkCommandBufferLevel    level;
  5.2316 -    uint32_t                commandBufferCount;
  5.2317 -} VkCommandBufferAllocateInfo;
  5.2318 -
  5.2319 -typedef struct VkCommandBufferInheritanceInfo {
  5.2320 -    VkStructureType                  sType;
  5.2321 -    const void*                      pNext;
  5.2322 -    VkRenderPass                     renderPass;
  5.2323 -    uint32_t                         subpass;
  5.2324 -    VkFramebuffer                    framebuffer;
  5.2325 -    VkBool32                         occlusionQueryEnable;
  5.2326 -    VkQueryControlFlags              queryFlags;
  5.2327 -    VkQueryPipelineStatisticFlags    pipelineStatistics;
  5.2328 -} VkCommandBufferInheritanceInfo;
  5.2329 -
  5.2330 -typedef struct VkCommandBufferBeginInfo {
  5.2331 -    VkStructureType                          sType;
  5.2332 -    const void*                              pNext;
  5.2333 -    VkCommandBufferUsageFlags                flags;
  5.2334 -    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
  5.2335 -} VkCommandBufferBeginInfo;
  5.2336 -
  5.2337 -typedef struct VkBufferCopy {
  5.2338 -    VkDeviceSize    srcOffset;
  5.2339 -    VkDeviceSize    dstOffset;
  5.2340 -    VkDeviceSize    size;
  5.2341 -} VkBufferCopy;
  5.2342 -
  5.2343 -typedef struct VkImageSubresourceLayers {
  5.2344 -    VkImageAspectFlags    aspectMask;
  5.2345 -    uint32_t              mipLevel;
  5.2346 -    uint32_t              baseArrayLayer;
  5.2347 -    uint32_t              layerCount;
  5.2348 -} VkImageSubresourceLayers;
  5.2349 -
  5.2350 -typedef struct VkImageCopy {
  5.2351 -    VkImageSubresourceLayers    srcSubresource;
  5.2352 -    VkOffset3D                  srcOffset;
  5.2353 -    VkImageSubresourceLayers    dstSubresource;
  5.2354 -    VkOffset3D                  dstOffset;
  5.2355 -    VkExtent3D                  extent;
  5.2356 -} VkImageCopy;
  5.2357 -
  5.2358 -typedef struct VkImageBlit {
  5.2359 -    VkImageSubresourceLayers    srcSubresource;
  5.2360 -    VkOffset3D                  srcOffsets[2];
  5.2361 -    VkImageSubresourceLayers    dstSubresource;
  5.2362 -    VkOffset3D                  dstOffsets[2];
  5.2363 -} VkImageBlit;
  5.2364 -
  5.2365 -typedef struct VkBufferImageCopy {
  5.2366 -    VkDeviceSize                bufferOffset;
  5.2367 -    uint32_t                    bufferRowLength;
  5.2368 -    uint32_t                    bufferImageHeight;
  5.2369 -    VkImageSubresourceLayers    imageSubresource;
  5.2370 -    VkOffset3D                  imageOffset;
  5.2371 -    VkExtent3D                  imageExtent;
  5.2372 -} VkBufferImageCopy;
  5.2373 -
  5.2374 -typedef union VkClearColorValue {
  5.2375 -    float       float32[4];
  5.2376 -    int32_t     int32[4];
  5.2377 -    uint32_t    uint32[4];
  5.2378 -} VkClearColorValue;
  5.2379 -
  5.2380 -typedef struct VkClearDepthStencilValue {
  5.2381 -    float       depth;
  5.2382 -    uint32_t    stencil;
  5.2383 -} VkClearDepthStencilValue;
  5.2384 -
  5.2385 -typedef union VkClearValue {
  5.2386 -    VkClearColorValue           color;
  5.2387 -    VkClearDepthStencilValue    depthStencil;
  5.2388 -} VkClearValue;
  5.2389 -
  5.2390 -typedef struct VkClearAttachment {
  5.2391 -    VkImageAspectFlags    aspectMask;
  5.2392 -    uint32_t              colorAttachment;
  5.2393 -    VkClearValue          clearValue;
  5.2394 -} VkClearAttachment;
  5.2395 -
  5.2396 -typedef struct VkClearRect {
  5.2397 -    VkRect2D    rect;
  5.2398 -    uint32_t    baseArrayLayer;
  5.2399 -    uint32_t    layerCount;
  5.2400 -} VkClearRect;
  5.2401 -
  5.2402 -typedef struct VkImageResolve {
  5.2403 -    VkImageSubresourceLayers    srcSubresource;
  5.2404 -    VkOffset3D                  srcOffset;
  5.2405 -    VkImageSubresourceLayers    dstSubresource;
  5.2406 -    VkOffset3D                  dstOffset;
  5.2407 -    VkExtent3D                  extent;
  5.2408 -} VkImageResolve;
  5.2409 -
  5.2410 -typedef struct VkMemoryBarrier {
  5.2411 -    VkStructureType    sType;
  5.2412 -    const void*        pNext;
  5.2413 -    VkAccessFlags      srcAccessMask;
  5.2414 -    VkAccessFlags      dstAccessMask;
  5.2415 -} VkMemoryBarrier;
  5.2416 -
  5.2417 -typedef struct VkBufferMemoryBarrier {
  5.2418 -    VkStructureType    sType;
  5.2419 -    const void*        pNext;
  5.2420 -    VkAccessFlags      srcAccessMask;
  5.2421 -    VkAccessFlags      dstAccessMask;
  5.2422 -    uint32_t           srcQueueFamilyIndex;
  5.2423 -    uint32_t           dstQueueFamilyIndex;
  5.2424 -    VkBuffer           buffer;
  5.2425 -    VkDeviceSize       offset;
  5.2426 -    VkDeviceSize       size;
  5.2427 -} VkBufferMemoryBarrier;
  5.2428 -
  5.2429 -typedef struct VkImageMemoryBarrier {
  5.2430 -    VkStructureType            sType;
  5.2431 -    const void*                pNext;
  5.2432 -    VkAccessFlags              srcAccessMask;
  5.2433 -    VkAccessFlags              dstAccessMask;
  5.2434 -    VkImageLayout              oldLayout;
  5.2435 -    VkImageLayout              newLayout;
  5.2436 -    uint32_t                   srcQueueFamilyIndex;
  5.2437 -    uint32_t                   dstQueueFamilyIndex;
  5.2438 -    VkImage                    image;
  5.2439 -    VkImageSubresourceRange    subresourceRange;
  5.2440 -} VkImageMemoryBarrier;
  5.2441 -
  5.2442 -typedef struct VkRenderPassBeginInfo {
  5.2443 -    VkStructureType        sType;
  5.2444 -    const void*            pNext;
  5.2445 -    VkRenderPass           renderPass;
  5.2446 -    VkFramebuffer          framebuffer;
  5.2447 -    VkRect2D               renderArea;
  5.2448 -    uint32_t               clearValueCount;
  5.2449 -    const VkClearValue*    pClearValues;
  5.2450 -} VkRenderPassBeginInfo;
  5.2451 -
  5.2452 -typedef struct VkDispatchIndirectCommand {
  5.2453 -    uint32_t    x;
  5.2454 -    uint32_t    y;
  5.2455 -    uint32_t    z;
  5.2456 -} VkDispatchIndirectCommand;
  5.2457 -
  5.2458 -typedef struct VkDrawIndexedIndirectCommand {
  5.2459 -    uint32_t    indexCount;
  5.2460 -    uint32_t    instanceCount;
  5.2461 -    uint32_t    firstIndex;
  5.2462 -    int32_t     vertexOffset;
  5.2463 -    uint32_t    firstInstance;
  5.2464 -} VkDrawIndexedIndirectCommand;
  5.2465 -
  5.2466 -typedef struct VkDrawIndirectCommand {
  5.2467 -    uint32_t    vertexCount;
  5.2468 -    uint32_t    instanceCount;
  5.2469 -    uint32_t    firstVertex;
  5.2470 -    uint32_t    firstInstance;
  5.2471 -} VkDrawIndirectCommand;
  5.2472 -
  5.2473 -
  5.2474 -typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
  5.2475 -typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
  5.2476 -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
  5.2477 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
  5.2478 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
  5.2479 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
  5.2480 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
  5.2481 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
  5.2482 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
  5.2483 -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
  5.2484 -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
  5.2485 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
  5.2486 -typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
  5.2487 -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
  5.2488 -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
  5.2489 -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
  5.2490 -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
  5.2491 -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
  5.2492 -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
  5.2493 -typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
  5.2494 -typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
  5.2495 -typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
  5.2496 -typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
  5.2497 -typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
  5.2498 -typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
  5.2499 -typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
  5.2500 -typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
  5.2501 -typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
  5.2502 -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
  5.2503 -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
  5.2504 -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
  5.2505 -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
  5.2506 -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
  5.2507 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
  5.2508 -typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
  5.2509 -typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  5.2510 -typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
  5.2511 -typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
  5.2512 -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
  5.2513 -typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
  5.2514 -typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
  5.2515 -typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
  5.2516 -typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
  5.2517 -typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
  5.2518 -typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
  5.2519 -typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
  5.2520 -typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
  5.2521 -typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
  5.2522 -typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
  5.2523 -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);
  5.2524 -typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
  5.2525 -typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
  5.2526 -typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
  5.2527 -typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
  5.2528 -typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
  5.2529 -typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
  5.2530 -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
  5.2531 -typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
  5.2532 -typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
  5.2533 -typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
  5.2534 -typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
  5.2535 -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
  5.2536 -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
  5.2537 -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
  5.2538 -typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
  5.2539 -typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
  5.2540 -typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
  5.2541 -typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
  5.2542 -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
  5.2543 -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
  5.2544 -typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
  5.2545 -typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
  5.2546 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
  5.2547 -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
  5.2548 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
  5.2549 -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
  5.2550 -typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
  5.2551 -typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
  5.2552 -typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
  5.2553 -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
  5.2554 -typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
  5.2555 -typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
  5.2556 -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
  5.2557 -typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
  5.2558 -typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
  5.2559 -typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
  5.2560 -typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
  5.2561 -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
  5.2562 -typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
  5.2563 -typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
  5.2564 -typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
  5.2565 -typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
  5.2566 -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
  5.2567 -typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
  5.2568 -typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
  5.2569 -typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
  5.2570 -typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
  5.2571 -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
  5.2572 -typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
  5.2573 -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
  5.2574 -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
  5.2575 -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
  5.2576 -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
  5.2577 -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);
  5.2578 -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
  5.2579 -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
  5.2580 -typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
  5.2581 -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
  5.2582 -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
  5.2583 -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
  5.2584 -typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
  5.2585 -typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
  5.2586 -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
  5.2587 -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
  5.2588 -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
  5.2589 -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
  5.2590 -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
  5.2591 -typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
  5.2592 -typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
  5.2593 -typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
  5.2594 -typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
  5.2595 -typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
  5.2596 -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
  5.2597 -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
  5.2598 -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
  5.2599 -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);
  5.2600 -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);
  5.2601 -typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
  5.2602 -typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
  5.2603 -typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
  5.2604 -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
  5.2605 -typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
  5.2606 -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
  5.2607 -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
  5.2608 -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
  5.2609 -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
  5.2610 -typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
  5.2611 -
  5.2612 -#ifndef VK_NO_PROTOTYPES
  5.2613 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
  5.2614 -    const VkInstanceCreateInfo*                 pCreateInfo,
  5.2615 -    const VkAllocationCallbacks*                pAllocator,
  5.2616 -    VkInstance*                                 pInstance);
  5.2617 -
  5.2618 -VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
  5.2619 -    VkInstance                                  instance,
  5.2620 -    const VkAllocationCallbacks*                pAllocator);
  5.2621 -
  5.2622 -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
  5.2623 -    VkInstance                                  instance,
  5.2624 -    uint32_t*                                   pPhysicalDeviceCount,
  5.2625 -    VkPhysicalDevice*                           pPhysicalDevices);
  5.2626 -
  5.2627 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
  5.2628 -    VkPhysicalDevice                            physicalDevice,
  5.2629 -    VkPhysicalDeviceFeatures*                   pFeatures);
  5.2630 -
  5.2631 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
  5.2632 -    VkPhysicalDevice                            physicalDevice,
  5.2633 -    VkFormat                                    format,
  5.2634 -    VkFormatProperties*                         pFormatProperties);
  5.2635 -
  5.2636 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
  5.2637 -    VkPhysicalDevice                            physicalDevice,
  5.2638 -    VkFormat                                    format,
  5.2639 -    VkImageType                                 type,
  5.2640 -    VkImageTiling                               tiling,
  5.2641 -    VkImageUsageFlags                           usage,
  5.2642 -    VkImageCreateFlags                          flags,
  5.2643 -    VkImageFormatProperties*                    pImageFormatProperties);
  5.2644 -
  5.2645 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
  5.2646 -    VkPhysicalDevice                            physicalDevice,
  5.2647 -    VkPhysicalDeviceProperties*                 pProperties);
  5.2648 -
  5.2649 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
  5.2650 -    VkPhysicalDevice                            physicalDevice,
  5.2651 -    uint32_t*                                   pQueueFamilyPropertyCount,
  5.2652 -    VkQueueFamilyProperties*                    pQueueFamilyProperties);
  5.2653 -
  5.2654 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
  5.2655 -    VkPhysicalDevice                            physicalDevice,
  5.2656 -    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
  5.2657 -
  5.2658 -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
  5.2659 -    VkInstance                                  instance,
  5.2660 -    const char*                                 pName);
  5.2661 -
  5.2662 -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
  5.2663 -    VkDevice                                    device,
  5.2664 -    const char*                                 pName);
  5.2665 -
  5.2666 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
  5.2667 -    VkPhysicalDevice                            physicalDevice,
  5.2668 -    const VkDeviceCreateInfo*                   pCreateInfo,
  5.2669 -    const VkAllocationCallbacks*                pAllocator,
  5.2670 -    VkDevice*                                   pDevice);
  5.2671 -
  5.2672 -VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
  5.2673 -    VkDevice                                    device,
  5.2674 -    const VkAllocationCallbacks*                pAllocator);
  5.2675 -
  5.2676 -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
  5.2677 -    const char*                                 pLayerName,
  5.2678 -    uint32_t*                                   pPropertyCount,
  5.2679 -    VkExtensionProperties*                      pProperties);
  5.2680 -
  5.2681 -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
  5.2682 -    VkPhysicalDevice                            physicalDevice,
  5.2683 -    const char*                                 pLayerName,
  5.2684 -    uint32_t*                                   pPropertyCount,
  5.2685 -    VkExtensionProperties*                      pProperties);
  5.2686 -
  5.2687 -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
  5.2688 -    uint32_t*                                   pPropertyCount,
  5.2689 -    VkLayerProperties*                          pProperties);
  5.2690 -
  5.2691 -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
  5.2692 -    VkPhysicalDevice                            physicalDevice,
  5.2693 -    uint32_t*                                   pPropertyCount,
  5.2694 -    VkLayerProperties*                          pProperties);
  5.2695 -
  5.2696 -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
  5.2697 -    VkDevice                                    device,
  5.2698 -    uint32_t                                    queueFamilyIndex,
  5.2699 -    uint32_t                                    queueIndex,
  5.2700 -    VkQueue*                                    pQueue);
  5.2701 -
  5.2702 -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
  5.2703 -    VkQueue                                     queue,
  5.2704 -    uint32_t                                    submitCount,
  5.2705 -    const VkSubmitInfo*                         pSubmits,
  5.2706 -    VkFence                                     fence);
  5.2707 -
  5.2708 -VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
  5.2709 -    VkQueue                                     queue);
  5.2710 -
  5.2711 -VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
  5.2712 -    VkDevice                                    device);
  5.2713 -
  5.2714 -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
  5.2715 -    VkDevice                                    device,
  5.2716 -    const VkMemoryAllocateInfo*                 pAllocateInfo,
  5.2717 -    const VkAllocationCallbacks*                pAllocator,
  5.2718 -    VkDeviceMemory*                             pMemory);
  5.2719 -
  5.2720 -VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
  5.2721 -    VkDevice                                    device,
  5.2722 -    VkDeviceMemory                              memory,
  5.2723 -    const VkAllocationCallbacks*                pAllocator);
  5.2724 -
  5.2725 -VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
  5.2726 -    VkDevice                                    device,
  5.2727 -    VkDeviceMemory                              memory,
  5.2728 -    VkDeviceSize                                offset,
  5.2729 -    VkDeviceSize                                size,
  5.2730 -    VkMemoryMapFlags                            flags,
  5.2731 -    void**                                      ppData);
  5.2732 -
  5.2733 -VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
  5.2734 -    VkDevice                                    device,
  5.2735 -    VkDeviceMemory                              memory);
  5.2736 -
  5.2737 -VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
  5.2738 -    VkDevice                                    device,
  5.2739 -    uint32_t                                    memoryRangeCount,
  5.2740 -    const VkMappedMemoryRange*                  pMemoryRanges);
  5.2741 -
  5.2742 -VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
  5.2743 -    VkDevice                                    device,
  5.2744 -    uint32_t                                    memoryRangeCount,
  5.2745 -    const VkMappedMemoryRange*                  pMemoryRanges);
  5.2746 -
  5.2747 -VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
  5.2748 -    VkDevice                                    device,
  5.2749 -    VkDeviceMemory                              memory,
  5.2750 -    VkDeviceSize*                               pCommittedMemoryInBytes);
  5.2751 -
  5.2752 -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
  5.2753 -    VkDevice                                    device,
  5.2754 -    VkBuffer                                    buffer,
  5.2755 -    VkDeviceMemory                              memory,
  5.2756 -    VkDeviceSize                                memoryOffset);
  5.2757 -
  5.2758 -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
  5.2759 -    VkDevice                                    device,
  5.2760 -    VkImage                                     image,
  5.2761 -    VkDeviceMemory                              memory,
  5.2762 -    VkDeviceSize                                memoryOffset);
  5.2763 -
  5.2764 -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
  5.2765 -    VkDevice                                    device,
  5.2766 -    VkBuffer                                    buffer,
  5.2767 -    VkMemoryRequirements*                       pMemoryRequirements);
  5.2768 -
  5.2769 -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
  5.2770 -    VkDevice                                    device,
  5.2771 -    VkImage                                     image,
  5.2772 -    VkMemoryRequirements*                       pMemoryRequirements);
  5.2773 -
  5.2774 -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
  5.2775 -    VkDevice                                    device,
  5.2776 -    VkImage                                     image,
  5.2777 -    uint32_t*                                   pSparseMemoryRequirementCount,
  5.2778 -    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
  5.2779 -
  5.2780 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
  5.2781 -    VkPhysicalDevice                            physicalDevice,
  5.2782 -    VkFormat                                    format,
  5.2783 -    VkImageType                                 type,
  5.2784 -    VkSampleCountFlagBits                       samples,
  5.2785 -    VkImageUsageFlags                           usage,
  5.2786 -    VkImageTiling                               tiling,
  5.2787 -    uint32_t*                                   pPropertyCount,
  5.2788 -    VkSparseImageFormatProperties*              pProperties);
  5.2789 -
  5.2790 -VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
  5.2791 -    VkQueue                                     queue,
  5.2792 -    uint32_t                                    bindInfoCount,
  5.2793 -    const VkBindSparseInfo*                     pBindInfo,
  5.2794 -    VkFence                                     fence);
  5.2795 -
  5.2796 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
  5.2797 -    VkDevice                                    device,
  5.2798 -    const VkFenceCreateInfo*                    pCreateInfo,
  5.2799 -    const VkAllocationCallbacks*                pAllocator,
  5.2800 -    VkFence*                                    pFence);
  5.2801 -
  5.2802 -VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
  5.2803 -    VkDevice                                    device,
  5.2804 -    VkFence                                     fence,
  5.2805 -    const VkAllocationCallbacks*                pAllocator);
  5.2806 -
  5.2807 -VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
  5.2808 -    VkDevice                                    device,
  5.2809 -    uint32_t                                    fenceCount,
  5.2810 -    const VkFence*                              pFences);
  5.2811 -
  5.2812 -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
  5.2813 -    VkDevice                                    device,
  5.2814 -    VkFence                                     fence);
  5.2815 -
  5.2816 -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
  5.2817 -    VkDevice                                    device,
  5.2818 -    uint32_t                                    fenceCount,
  5.2819 -    const VkFence*                              pFences,
  5.2820 -    VkBool32                                    waitAll,
  5.2821 -    uint64_t                                    timeout);
  5.2822 -
  5.2823 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
  5.2824 -    VkDevice                                    device,
  5.2825 -    const VkSemaphoreCreateInfo*                pCreateInfo,
  5.2826 -    const VkAllocationCallbacks*                pAllocator,
  5.2827 -    VkSemaphore*                                pSemaphore);
  5.2828 -
  5.2829 -VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
  5.2830 -    VkDevice                                    device,
  5.2831 -    VkSemaphore                                 semaphore,
  5.2832 -    const VkAllocationCallbacks*                pAllocator);
  5.2833 -
  5.2834 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
  5.2835 -    VkDevice                                    device,
  5.2836 -    const VkEventCreateInfo*                    pCreateInfo,
  5.2837 -    const VkAllocationCallbacks*                pAllocator,
  5.2838 -    VkEvent*                                    pEvent);
  5.2839 -
  5.2840 -VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
  5.2841 -    VkDevice                                    device,
  5.2842 -    VkEvent                                     event,
  5.2843 -    const VkAllocationCallbacks*                pAllocator);
  5.2844 -
  5.2845 -VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
  5.2846 -    VkDevice                                    device,
  5.2847 -    VkEvent                                     event);
  5.2848 -
  5.2849 -VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
  5.2850 -    VkDevice                                    device,
  5.2851 -    VkEvent                                     event);
  5.2852 -
  5.2853 -VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
  5.2854 -    VkDevice                                    device,
  5.2855 -    VkEvent                                     event);
  5.2856 -
  5.2857 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
  5.2858 -    VkDevice                                    device,
  5.2859 -    const VkQueryPoolCreateInfo*                pCreateInfo,
  5.2860 -    const VkAllocationCallbacks*                pAllocator,
  5.2861 -    VkQueryPool*                                pQueryPool);
  5.2862 -
  5.2863 -VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
  5.2864 -    VkDevice                                    device,
  5.2865 -    VkQueryPool                                 queryPool,
  5.2866 -    const VkAllocationCallbacks*                pAllocator);
  5.2867 -
  5.2868 -VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
  5.2869 -    VkDevice                                    device,
  5.2870 -    VkQueryPool                                 queryPool,
  5.2871 -    uint32_t                                    firstQuery,
  5.2872 -    uint32_t                                    queryCount,
  5.2873 -    size_t                                      dataSize,
  5.2874 -    void*                                       pData,
  5.2875 -    VkDeviceSize                                stride,
  5.2876 -    VkQueryResultFlags                          flags);
  5.2877 -
  5.2878 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
  5.2879 -    VkDevice                                    device,
  5.2880 -    const VkBufferCreateInfo*                   pCreateInfo,
  5.2881 -    const VkAllocationCallbacks*                pAllocator,
  5.2882 -    VkBuffer*                                   pBuffer);
  5.2883 -
  5.2884 -VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
  5.2885 -    VkDevice                                    device,
  5.2886 -    VkBuffer                                    buffer,
  5.2887 -    const VkAllocationCallbacks*                pAllocator);
  5.2888 -
  5.2889 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
  5.2890 -    VkDevice                                    device,
  5.2891 -    const VkBufferViewCreateInfo*               pCreateInfo,
  5.2892 -    const VkAllocationCallbacks*                pAllocator,
  5.2893 -    VkBufferView*                               pView);
  5.2894 -
  5.2895 -VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
  5.2896 -    VkDevice                                    device,
  5.2897 -    VkBufferView                                bufferView,
  5.2898 -    const VkAllocationCallbacks*                pAllocator);
  5.2899 -
  5.2900 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
  5.2901 -    VkDevice                                    device,
  5.2902 -    const VkImageCreateInfo*                    pCreateInfo,
  5.2903 -    const VkAllocationCallbacks*                pAllocator,
  5.2904 -    VkImage*                                    pImage);
  5.2905 -
  5.2906 -VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
  5.2907 -    VkDevice                                    device,
  5.2908 -    VkImage                                     image,
  5.2909 -    const VkAllocationCallbacks*                pAllocator);
  5.2910 -
  5.2911 -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
  5.2912 -    VkDevice                                    device,
  5.2913 -    VkImage                                     image,
  5.2914 -    const VkImageSubresource*                   pSubresource,
  5.2915 -    VkSubresourceLayout*                        pLayout);
  5.2916 -
  5.2917 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
  5.2918 -    VkDevice                                    device,
  5.2919 -    const VkImageViewCreateInfo*                pCreateInfo,
  5.2920 -    const VkAllocationCallbacks*                pAllocator,
  5.2921 -    VkImageView*                                pView);
  5.2922 -
  5.2923 -VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
  5.2924 -    VkDevice                                    device,
  5.2925 -    VkImageView                                 imageView,
  5.2926 -    const VkAllocationCallbacks*                pAllocator);
  5.2927 -
  5.2928 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
  5.2929 -    VkDevice                                    device,
  5.2930 -    const VkShaderModuleCreateInfo*             pCreateInfo,
  5.2931 -    const VkAllocationCallbacks*                pAllocator,
  5.2932 -    VkShaderModule*                             pShaderModule);
  5.2933 -
  5.2934 -VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
  5.2935 -    VkDevice                                    device,
  5.2936 -    VkShaderModule                              shaderModule,
  5.2937 -    const VkAllocationCallbacks*                pAllocator);
  5.2938 -
  5.2939 -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
  5.2940 -    VkDevice                                    device,
  5.2941 -    const VkPipelineCacheCreateInfo*            pCreateInfo,
  5.2942 -    const VkAllocationCallbacks*                pAllocator,
  5.2943 -    VkPipelineCache*                            pPipelineCache);
  5.2944 -
  5.2945 -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
  5.2946 -    VkDevice                                    device,
  5.2947 -    VkPipelineCache                             pipelineCache,
  5.2948 -    const VkAllocationCallbacks*                pAllocator);
  5.2949 -
  5.2950 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
  5.2951 -    VkDevice                                    device,
  5.2952 -    VkPipelineCache                             pipelineCache,
  5.2953 -    size_t*                                     pDataSize,
  5.2954 -    void*                                       pData);
  5.2955 -
  5.2956 -VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
  5.2957 -    VkDevice                                    device,
  5.2958 -    VkPipelineCache                             dstCache,
  5.2959 -    uint32_t                                    srcCacheCount,
  5.2960 -    const VkPipelineCache*                      pSrcCaches);
  5.2961 -
  5.2962 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
  5.2963 -    VkDevice                                    device,
  5.2964 -    VkPipelineCache                             pipelineCache,
  5.2965 -    uint32_t                                    createInfoCount,
  5.2966 -    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
  5.2967 -    const VkAllocationCallbacks*                pAllocator,
  5.2968 -    VkPipeline*                                 pPipelines);
  5.2969 -
  5.2970 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
  5.2971 -    VkDevice                                    device,
  5.2972 -    VkPipelineCache                             pipelineCache,
  5.2973 -    uint32_t                                    createInfoCount,
  5.2974 -    const VkComputePipelineCreateInfo*          pCreateInfos,
  5.2975 -    const VkAllocationCallbacks*                pAllocator,
  5.2976 -    VkPipeline*                                 pPipelines);
  5.2977 -
  5.2978 -VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
  5.2979 -    VkDevice                                    device,
  5.2980 -    VkPipeline                                  pipeline,
  5.2981 -    const VkAllocationCallbacks*                pAllocator);
  5.2982 -
  5.2983 -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
  5.2984 -    VkDevice                                    device,
  5.2985 -    const VkPipelineLayoutCreateInfo*           pCreateInfo,
  5.2986 -    const VkAllocationCallbacks*                pAllocator,
  5.2987 -    VkPipelineLayout*                           pPipelineLayout);
  5.2988 -
  5.2989 -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
  5.2990 -    VkDevice                                    device,
  5.2991 -    VkPipelineLayout                            pipelineLayout,
  5.2992 -    const VkAllocationCallbacks*                pAllocator);
  5.2993 -
  5.2994 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
  5.2995 -    VkDevice                                    device,
  5.2996 -    const VkSamplerCreateInfo*                  pCreateInfo,
  5.2997 -    const VkAllocationCallbacks*                pAllocator,
  5.2998 -    VkSampler*                                  pSampler);
  5.2999 -
  5.3000 -VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
  5.3001 -    VkDevice                                    device,
  5.3002 -    VkSampler                                   sampler,
  5.3003 -    const VkAllocationCallbacks*                pAllocator);
  5.3004 -
  5.3005 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
  5.3006 -    VkDevice                                    device,
  5.3007 -    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
  5.3008 -    const VkAllocationCallbacks*                pAllocator,
  5.3009 -    VkDescriptorSetLayout*                      pSetLayout);
  5.3010 -
  5.3011 -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
  5.3012 -    VkDevice                                    device,
  5.3013 -    VkDescriptorSetLayout                       descriptorSetLayout,
  5.3014 -    const VkAllocationCallbacks*                pAllocator);
  5.3015 -
  5.3016 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
  5.3017 -    VkDevice                                    device,
  5.3018 -    const VkDescriptorPoolCreateInfo*           pCreateInfo,
  5.3019 -    const VkAllocationCallbacks*                pAllocator,
  5.3020 -    VkDescriptorPool*                           pDescriptorPool);
  5.3021 -
  5.3022 -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
  5.3023 -    VkDevice                                    device,
  5.3024 -    VkDescriptorPool                            descriptorPool,
  5.3025 -    const VkAllocationCallbacks*                pAllocator);
  5.3026 -
  5.3027 -VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
  5.3028 -    VkDevice                                    device,
  5.3029 -    VkDescriptorPool                            descriptorPool,
  5.3030 -    VkDescriptorPoolResetFlags                  flags);
  5.3031 -
  5.3032 -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
  5.3033 -    VkDevice                                    device,
  5.3034 -    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
  5.3035 -    VkDescriptorSet*                            pDescriptorSets);
  5.3036 -
  5.3037 -VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
  5.3038 -    VkDevice                                    device,
  5.3039 -    VkDescriptorPool                            descriptorPool,
  5.3040 -    uint32_t                                    descriptorSetCount,
  5.3041 -    const VkDescriptorSet*                      pDescriptorSets);
  5.3042 -
  5.3043 -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
  5.3044 -    VkDevice                                    device,
  5.3045 -    uint32_t                                    descriptorWriteCount,
  5.3046 -    const VkWriteDescriptorSet*                 pDescriptorWrites,
  5.3047 -    uint32_t                                    descriptorCopyCount,
  5.3048 -    const VkCopyDescriptorSet*                  pDescriptorCopies);
  5.3049 -
  5.3050 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
  5.3051 -    VkDevice                                    device,
  5.3052 -    const VkFramebufferCreateInfo*              pCreateInfo,
  5.3053 -    const VkAllocationCallbacks*                pAllocator,
  5.3054 -    VkFramebuffer*                              pFramebuffer);
  5.3055 -
  5.3056 -VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
  5.3057 -    VkDevice                                    device,
  5.3058 -    VkFramebuffer                               framebuffer,
  5.3059 -    const VkAllocationCallbacks*                pAllocator);
  5.3060 -
  5.3061 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
  5.3062 -    VkDevice                                    device,
  5.3063 -    const VkRenderPassCreateInfo*               pCreateInfo,
  5.3064 -    const VkAllocationCallbacks*                pAllocator,
  5.3065 -    VkRenderPass*                               pRenderPass);
  5.3066 -
  5.3067 -VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
  5.3068 -    VkDevice                                    device,
  5.3069 -    VkRenderPass                                renderPass,
  5.3070 -    const VkAllocationCallbacks*                pAllocator);
  5.3071 -
  5.3072 -VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
  5.3073 -    VkDevice                                    device,
  5.3074 -    VkRenderPass                                renderPass,
  5.3075 -    VkExtent2D*                                 pGranularity);
  5.3076 -
  5.3077 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
  5.3078 -    VkDevice                                    device,
  5.3079 -    const VkCommandPoolCreateInfo*              pCreateInfo,
  5.3080 -    const VkAllocationCallbacks*                pAllocator,
  5.3081 -    VkCommandPool*                              pCommandPool);
  5.3082 -
  5.3083 -VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
  5.3084 -    VkDevice                                    device,
  5.3085 -    VkCommandPool                               commandPool,
  5.3086 -    const VkAllocationCallbacks*                pAllocator);
  5.3087 -
  5.3088 -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
  5.3089 -    VkDevice                                    device,
  5.3090 -    VkCommandPool                               commandPool,
  5.3091 -    VkCommandPoolResetFlags                     flags);
  5.3092 -
  5.3093 -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
  5.3094 -    VkDevice                                    device,
  5.3095 -    const VkCommandBufferAllocateInfo*          pAllocateInfo,
  5.3096 -    VkCommandBuffer*                            pCommandBuffers);
  5.3097 -
  5.3098 -VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
  5.3099 -    VkDevice                                    device,
  5.3100 -    VkCommandPool                               commandPool,
  5.3101 -    uint32_t                                    commandBufferCount,
  5.3102 -    const VkCommandBuffer*                      pCommandBuffers);
  5.3103 -
  5.3104 -VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
  5.3105 -    VkCommandBuffer                             commandBuffer,
  5.3106 -    const VkCommandBufferBeginInfo*             pBeginInfo);
  5.3107 -
  5.3108 -VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
  5.3109 -    VkCommandBuffer                             commandBuffer);
  5.3110 -
  5.3111 -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
  5.3112 -    VkCommandBuffer                             commandBuffer,
  5.3113 -    VkCommandBufferResetFlags                   flags);
  5.3114 -
  5.3115 -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
  5.3116 -    VkCommandBuffer                             commandBuffer,
  5.3117 -    VkPipelineBindPoint                         pipelineBindPoint,
  5.3118 -    VkPipeline                                  pipeline);
  5.3119 -
  5.3120 -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
  5.3121 -    VkCommandBuffer                             commandBuffer,
  5.3122 -    uint32_t                                    firstViewport,
  5.3123 -    uint32_t                                    viewportCount,
  5.3124 -    const VkViewport*                           pViewports);
  5.3125 -
  5.3126 -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
  5.3127 -    VkCommandBuffer                             commandBuffer,
  5.3128 -    uint32_t                                    firstScissor,
  5.3129 -    uint32_t                                    scissorCount,
  5.3130 -    const VkRect2D*                             pScissors);
  5.3131 -
  5.3132 -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
  5.3133 -    VkCommandBuffer                             commandBuffer,
  5.3134 -    float                                       lineWidth);
  5.3135 -
  5.3136 -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
  5.3137 -    VkCommandBuffer                             commandBuffer,
  5.3138 -    float                                       depthBiasConstantFactor,
  5.3139 -    float                                       depthBiasClamp,
  5.3140 -    float                                       depthBiasSlopeFactor);
  5.3141 -
  5.3142 -VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
  5.3143 -    VkCommandBuffer                             commandBuffer,
  5.3144 -    const float                                 blendConstants[4]);
  5.3145 -
  5.3146 -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
  5.3147 -    VkCommandBuffer                             commandBuffer,
  5.3148 -    float                                       minDepthBounds,
  5.3149 -    float                                       maxDepthBounds);
  5.3150 -
  5.3151 -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
  5.3152 -    VkCommandBuffer                             commandBuffer,
  5.3153 -    VkStencilFaceFlags                          faceMask,
  5.3154 -    uint32_t                                    compareMask);
  5.3155 -
  5.3156 -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
  5.3157 -    VkCommandBuffer                             commandBuffer,
  5.3158 -    VkStencilFaceFlags                          faceMask,
  5.3159 -    uint32_t                                    writeMask);
  5.3160 -
  5.3161 -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
  5.3162 -    VkCommandBuffer                             commandBuffer,
  5.3163 -    VkStencilFaceFlags                          faceMask,
  5.3164 -    uint32_t                                    reference);
  5.3165 -
  5.3166 -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
  5.3167 -    VkCommandBuffer                             commandBuffer,
  5.3168 -    VkPipelineBindPoint                         pipelineBindPoint,
  5.3169 -    VkPipelineLayout                            layout,
  5.3170 -    uint32_t                                    firstSet,
  5.3171 -    uint32_t                                    descriptorSetCount,
  5.3172 -    const VkDescriptorSet*                      pDescriptorSets,
  5.3173 -    uint32_t                                    dynamicOffsetCount,
  5.3174 -    const uint32_t*                             pDynamicOffsets);
  5.3175 -
  5.3176 -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
  5.3177 -    VkCommandBuffer                             commandBuffer,
  5.3178 -    VkBuffer                                    buffer,
  5.3179 -    VkDeviceSize                                offset,
  5.3180 -    VkIndexType                                 indexType);
  5.3181 -
  5.3182 -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
  5.3183 -    VkCommandBuffer                             commandBuffer,
  5.3184 -    uint32_t                                    firstBinding,
  5.3185 -    uint32_t                                    bindingCount,
  5.3186 -    const VkBuffer*                             pBuffers,
  5.3187 -    const VkDeviceSize*                         pOffsets);
  5.3188 -
  5.3189 -VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
  5.3190 -    VkCommandBuffer                             commandBuffer,
  5.3191 -    uint32_t                                    vertexCount,
  5.3192 -    uint32_t                                    instanceCount,
  5.3193 -    uint32_t                                    firstVertex,
  5.3194 -    uint32_t                                    firstInstance);
  5.3195 -
  5.3196 -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
  5.3197 -    VkCommandBuffer                             commandBuffer,
  5.3198 -    uint32_t                                    indexCount,
  5.3199 -    uint32_t                                    instanceCount,
  5.3200 -    uint32_t                                    firstIndex,
  5.3201 -    int32_t                                     vertexOffset,
  5.3202 -    uint32_t                                    firstInstance);
  5.3203 -
  5.3204 -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
  5.3205 -    VkCommandBuffer                             commandBuffer,
  5.3206 -    VkBuffer                                    buffer,
  5.3207 -    VkDeviceSize                                offset,
  5.3208 -    uint32_t                                    drawCount,
  5.3209 -    uint32_t                                    stride);
  5.3210 -
  5.3211 -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
  5.3212 -    VkCommandBuffer                             commandBuffer,
  5.3213 -    VkBuffer                                    buffer,
  5.3214 -    VkDeviceSize                                offset,
  5.3215 -    uint32_t                                    drawCount,
  5.3216 -    uint32_t                                    stride);
  5.3217 -
  5.3218 -VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
  5.3219 -    VkCommandBuffer                             commandBuffer,
  5.3220 -    uint32_t                                    groupCountX,
  5.3221 -    uint32_t                                    groupCountY,
  5.3222 -    uint32_t                                    groupCountZ);
  5.3223 -
  5.3224 -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
  5.3225 -    VkCommandBuffer                             commandBuffer,
  5.3226 -    VkBuffer                                    buffer,
  5.3227 -    VkDeviceSize                                offset);
  5.3228 -
  5.3229 -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
  5.3230 -    VkCommandBuffer                             commandBuffer,
  5.3231 -    VkBuffer                                    srcBuffer,
  5.3232 -    VkBuffer                                    dstBuffer,
  5.3233 -    uint32_t                                    regionCount,
  5.3234 -    const VkBufferCopy*                         pRegions);
  5.3235 -
  5.3236 -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
  5.3237 -    VkCommandBuffer                             commandBuffer,
  5.3238 -    VkImage                                     srcImage,
  5.3239 -    VkImageLayout                               srcImageLayout,
  5.3240 -    VkImage                                     dstImage,
  5.3241 -    VkImageLayout                               dstImageLayout,
  5.3242 -    uint32_t                                    regionCount,
  5.3243 -    const VkImageCopy*                          pRegions);
  5.3244 -
  5.3245 -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
  5.3246 -    VkCommandBuffer                             commandBuffer,
  5.3247 -    VkImage                                     srcImage,
  5.3248 -    VkImageLayout                               srcImageLayout,
  5.3249 -    VkImage                                     dstImage,
  5.3250 -    VkImageLayout                               dstImageLayout,
  5.3251 -    uint32_t                                    regionCount,
  5.3252 -    const VkImageBlit*                          pRegions,
  5.3253 -    VkFilter                                    filter);
  5.3254 -
  5.3255 -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
  5.3256 -    VkCommandBuffer                             commandBuffer,
  5.3257 -    VkBuffer                                    srcBuffer,
  5.3258 -    VkImage                                     dstImage,
  5.3259 -    VkImageLayout                               dstImageLayout,
  5.3260 -    uint32_t                                    regionCount,
  5.3261 -    const VkBufferImageCopy*                    pRegions);
  5.3262 -
  5.3263 -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
  5.3264 -    VkCommandBuffer                             commandBuffer,
  5.3265 -    VkImage                                     srcImage,
  5.3266 -    VkImageLayout                               srcImageLayout,
  5.3267 -    VkBuffer                                    dstBuffer,
  5.3268 -    uint32_t                                    regionCount,
  5.3269 -    const VkBufferImageCopy*                    pRegions);
  5.3270 -
  5.3271 -VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
  5.3272 -    VkCommandBuffer                             commandBuffer,
  5.3273 -    VkBuffer                                    dstBuffer,
  5.3274 -    VkDeviceSize                                dstOffset,
  5.3275 -    VkDeviceSize                                dataSize,
  5.3276 -    const void*                                 pData);
  5.3277 -
  5.3278 -VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
  5.3279 -    VkCommandBuffer                             commandBuffer,
  5.3280 -    VkBuffer                                    dstBuffer,
  5.3281 -    VkDeviceSize                                dstOffset,
  5.3282 -    VkDeviceSize                                size,
  5.3283 -    uint32_t                                    data);
  5.3284 -
  5.3285 -VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
  5.3286 -    VkCommandBuffer                             commandBuffer,
  5.3287 -    VkImage                                     image,
  5.3288 -    VkImageLayout                               imageLayout,
  5.3289 -    const VkClearColorValue*                    pColor,
  5.3290 -    uint32_t                                    rangeCount,
  5.3291 -    const VkImageSubresourceRange*              pRanges);
  5.3292 -
  5.3293 -VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
  5.3294 -    VkCommandBuffer                             commandBuffer,
  5.3295 -    VkImage                                     image,
  5.3296 -    VkImageLayout                               imageLayout,
  5.3297 -    const VkClearDepthStencilValue*             pDepthStencil,
  5.3298 -    uint32_t                                    rangeCount,
  5.3299 -    const VkImageSubresourceRange*              pRanges);
  5.3300 -
  5.3301 -VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
  5.3302 -    VkCommandBuffer                             commandBuffer,
  5.3303 -    uint32_t                                    attachmentCount,
  5.3304 -    const VkClearAttachment*                    pAttachments,
  5.3305 -    uint32_t                                    rectCount,
  5.3306 -    const VkClearRect*                          pRects);
  5.3307 -
  5.3308 -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
  5.3309 -    VkCommandBuffer                             commandBuffer,
  5.3310 -    VkImage                                     srcImage,
  5.3311 -    VkImageLayout                               srcImageLayout,
  5.3312 -    VkImage                                     dstImage,
  5.3313 -    VkImageLayout                               dstImageLayout,
  5.3314 -    uint32_t                                    regionCount,
  5.3315 -    const VkImageResolve*                       pRegions);
  5.3316 -
  5.3317 -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
  5.3318 -    VkCommandBuffer                             commandBuffer,
  5.3319 -    VkEvent                                     event,
  5.3320 -    VkPipelineStageFlags                        stageMask);
  5.3321 -
  5.3322 -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
  5.3323 -    VkCommandBuffer                             commandBuffer,
  5.3324 -    VkEvent                                     event,
  5.3325 -    VkPipelineStageFlags                        stageMask);
  5.3326 -
  5.3327 -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
  5.3328 -    VkCommandBuffer                             commandBuffer,
  5.3329 -    uint32_t                                    eventCount,
  5.3330 -    const VkEvent*                              pEvents,
  5.3331 -    VkPipelineStageFlags                        srcStageMask,
  5.3332 -    VkPipelineStageFlags                        dstStageMask,
  5.3333 -    uint32_t                                    memoryBarrierCount,
  5.3334 -    const VkMemoryBarrier*                      pMemoryBarriers,
  5.3335 -    uint32_t                                    bufferMemoryBarrierCount,
  5.3336 -    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
  5.3337 -    uint32_t                                    imageMemoryBarrierCount,
  5.3338 -    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
  5.3339 -
  5.3340 -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
  5.3341 -    VkCommandBuffer                             commandBuffer,
  5.3342 -    VkPipelineStageFlags                        srcStageMask,
  5.3343 -    VkPipelineStageFlags                        dstStageMask,
  5.3344 -    VkDependencyFlags                           dependencyFlags,
  5.3345 -    uint32_t                                    memoryBarrierCount,
  5.3346 -    const VkMemoryBarrier*                      pMemoryBarriers,
  5.3347 -    uint32_t                                    bufferMemoryBarrierCount,
  5.3348 -    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
  5.3349 -    uint32_t                                    imageMemoryBarrierCount,
  5.3350 -    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
  5.3351 -
  5.3352 -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
  5.3353 -    VkCommandBuffer                             commandBuffer,
  5.3354 -    VkQueryPool                                 queryPool,
  5.3355 -    uint32_t                                    query,
  5.3356 -    VkQueryControlFlags                         flags);
  5.3357 -
  5.3358 -VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
  5.3359 -    VkCommandBuffer                             commandBuffer,
  5.3360 -    VkQueryPool                                 queryPool,
  5.3361 -    uint32_t                                    query);
  5.3362 -
  5.3363 -VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
  5.3364 -    VkCommandBuffer                             commandBuffer,
  5.3365 -    VkQueryPool                                 queryPool,
  5.3366 -    uint32_t                                    firstQuery,
  5.3367 -    uint32_t                                    queryCount);
  5.3368 -
  5.3369 -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
  5.3370 -    VkCommandBuffer                             commandBuffer,
  5.3371 -    VkPipelineStageFlagBits                     pipelineStage,
  5.3372 -    VkQueryPool                                 queryPool,
  5.3373 -    uint32_t                                    query);
  5.3374 -
  5.3375 -VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
  5.3376 -    VkCommandBuffer                             commandBuffer,
  5.3377 -    VkQueryPool                                 queryPool,
  5.3378 -    uint32_t                                    firstQuery,
  5.3379 -    uint32_t                                    queryCount,
  5.3380 -    VkBuffer                                    dstBuffer,
  5.3381 -    VkDeviceSize                                dstOffset,
  5.3382 -    VkDeviceSize                                stride,
  5.3383 -    VkQueryResultFlags                          flags);
  5.3384 -
  5.3385 -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
  5.3386 -    VkCommandBuffer                             commandBuffer,
  5.3387 -    VkPipelineLayout                            layout,
  5.3388 -    VkShaderStageFlags                          stageFlags,
  5.3389 -    uint32_t                                    offset,
  5.3390 -    uint32_t                                    size,
  5.3391 -    const void*                                 pValues);
  5.3392 -
  5.3393 -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
  5.3394 -    VkCommandBuffer                             commandBuffer,
  5.3395 -    const VkRenderPassBeginInfo*                pRenderPassBegin,
  5.3396 -    VkSubpassContents                           contents);
  5.3397 -
  5.3398 -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
  5.3399 -    VkCommandBuffer                             commandBuffer,
  5.3400 -    VkSubpassContents                           contents);
  5.3401 -
  5.3402 -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
  5.3403 -    VkCommandBuffer                             commandBuffer);
  5.3404 -
  5.3405 -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
  5.3406 -    VkCommandBuffer                             commandBuffer,
  5.3407 -    uint32_t                                    commandBufferCount,
  5.3408 -    const VkCommandBuffer*                      pCommandBuffers);
  5.3409 +#ifdef VK_USE_PLATFORM_ANDROID_KHR
  5.3410 +#include "vulkan_android.h"
  5.3411  #endif
  5.3412  
  5.3413 -#define VK_KHR_surface 1
  5.3414 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
  5.3415 -
  5.3416 -#define VK_KHR_SURFACE_SPEC_VERSION       25
  5.3417 -#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
  5.3418 -#define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
  5.3419 -
  5.3420 -
  5.3421 -typedef enum VkColorSpaceKHR {
  5.3422 -    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
  5.3423 -    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
  5.3424 -    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
  5.3425 -    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
  5.3426 -    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
  5.3427 -    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
  5.3428 -    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
  5.3429 -    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
  5.3430 -    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
  5.3431 -    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
  5.3432 -    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
  5.3433 -    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
  5.3434 -    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
  5.3435 -    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
  5.3436 -    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
  5.3437 -    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
  5.3438 -    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
  5.3439 -    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
  5.3440 -    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
  5.3441 -} VkColorSpaceKHR;
  5.3442 -
  5.3443 -typedef enum VkPresentModeKHR {
  5.3444 -    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
  5.3445 -    VK_PRESENT_MODE_MAILBOX_KHR = 1,
  5.3446 -    VK_PRESENT_MODE_FIFO_KHR = 2,
  5.3447 -    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
  5.3448 -    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
  5.3449 -    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
  5.3450 -    VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
  5.3451 -    VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
  5.3452 -    VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
  5.3453 -    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
  5.3454 -} VkPresentModeKHR;
  5.3455 -
  5.3456 -
  5.3457 -typedef enum VkSurfaceTransformFlagBitsKHR {
  5.3458 -    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
  5.3459 -    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
  5.3460 -    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
  5.3461 -    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
  5.3462 -    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
  5.3463 -    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
  5.3464 -    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
  5.3465 -    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
  5.3466 -    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
  5.3467 -    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.3468 -} VkSurfaceTransformFlagBitsKHR;
  5.3469 -typedef VkFlags VkSurfaceTransformFlagsKHR;
  5.3470 -
  5.3471 -typedef enum VkCompositeAlphaFlagBitsKHR {
  5.3472 -    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
  5.3473 -    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
  5.3474 -    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
  5.3475 -    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
  5.3476 -    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.3477 -} VkCompositeAlphaFlagBitsKHR;
  5.3478 -typedef VkFlags VkCompositeAlphaFlagsKHR;
  5.3479 -
  5.3480 -typedef struct VkSurfaceCapabilitiesKHR {
  5.3481 -    uint32_t                         minImageCount;
  5.3482 -    uint32_t                         maxImageCount;
  5.3483 -    VkExtent2D                       currentExtent;
  5.3484 -    VkExtent2D                       minImageExtent;
  5.3485 -    VkExtent2D                       maxImageExtent;
  5.3486 -    uint32_t                         maxImageArrayLayers;
  5.3487 -    VkSurfaceTransformFlagsKHR       supportedTransforms;
  5.3488 -    VkSurfaceTransformFlagBitsKHR    currentTransform;
  5.3489 -    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
  5.3490 -    VkImageUsageFlags                supportedUsageFlags;
  5.3491 -} VkSurfaceCapabilitiesKHR;
  5.3492 -
  5.3493 -typedef struct VkSurfaceFormatKHR {
  5.3494 -    VkFormat           format;
  5.3495 -    VkColorSpaceKHR    colorSpace;
  5.3496 -} VkSurfaceFormatKHR;
  5.3497 -
  5.3498 -
  5.3499 -typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
  5.3500 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
  5.3501 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
  5.3502 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
  5.3503 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
  5.3504 -
  5.3505 -#ifndef VK_NO_PROTOTYPES
  5.3506 -VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
  5.3507 -    VkInstance                                  instance,
  5.3508 -    VkSurfaceKHR                                surface,
  5.3509 -    const VkAllocationCallbacks*                pAllocator);
  5.3510 -
  5.3511 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
  5.3512 -    VkPhysicalDevice                            physicalDevice,
  5.3513 -    uint32_t                                    queueFamilyIndex,
  5.3514 -    VkSurfaceKHR                                surface,
  5.3515 -    VkBool32*                                   pSupported);
  5.3516 -
  5.3517 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
  5.3518 -    VkPhysicalDevice                            physicalDevice,
  5.3519 -    VkSurfaceKHR                                surface,
  5.3520 -    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
  5.3521 -
  5.3522 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
  5.3523 -    VkPhysicalDevice                            physicalDevice,
  5.3524 -    VkSurfaceKHR                                surface,
  5.3525 -    uint32_t*                                   pSurfaceFormatCount,
  5.3526 -    VkSurfaceFormatKHR*                         pSurfaceFormats);
  5.3527 -
  5.3528 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
  5.3529 -    VkPhysicalDevice                            physicalDevice,
  5.3530 -    VkSurfaceKHR                                surface,
  5.3531 -    uint32_t*                                   pPresentModeCount,
  5.3532 -    VkPresentModeKHR*                           pPresentModes);
  5.3533 -#endif
  5.3534 -
  5.3535 -#define VK_KHR_swapchain 1
  5.3536 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
  5.3537 -
  5.3538 -#define VK_KHR_SWAPCHAIN_SPEC_VERSION     68
  5.3539 -#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
  5.3540 -
  5.3541 -
  5.3542 -typedef enum VkSwapchainCreateFlagBitsKHR {
  5.3543 -    VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
  5.3544 -    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.3545 -} VkSwapchainCreateFlagBitsKHR;
  5.3546 -typedef VkFlags VkSwapchainCreateFlagsKHR;
  5.3547 -
  5.3548 -typedef struct VkSwapchainCreateInfoKHR {
  5.3549 -    VkStructureType                  sType;
  5.3550 -    const void*                      pNext;
  5.3551 -    VkSwapchainCreateFlagsKHR        flags;
  5.3552 -    VkSurfaceKHR                     surface;
  5.3553 -    uint32_t                         minImageCount;
  5.3554 -    VkFormat                         imageFormat;
  5.3555 -    VkColorSpaceKHR                  imageColorSpace;
  5.3556 -    VkExtent2D                       imageExtent;
  5.3557 -    uint32_t                         imageArrayLayers;
  5.3558 -    VkImageUsageFlags                imageUsage;
  5.3559 -    VkSharingMode                    imageSharingMode;
  5.3560 -    uint32_t                         queueFamilyIndexCount;
  5.3561 -    const uint32_t*                  pQueueFamilyIndices;
  5.3562 -    VkSurfaceTransformFlagBitsKHR    preTransform;
  5.3563 -    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
  5.3564 -    VkPresentModeKHR                 presentMode;
  5.3565 -    VkBool32                         clipped;
  5.3566 -    VkSwapchainKHR                   oldSwapchain;
  5.3567 -} VkSwapchainCreateInfoKHR;
  5.3568 -
  5.3569 -typedef struct VkPresentInfoKHR {
  5.3570 -    VkStructureType          sType;
  5.3571 -    const void*              pNext;
  5.3572 -    uint32_t                 waitSemaphoreCount;
  5.3573 -    const VkSemaphore*       pWaitSemaphores;
  5.3574 -    uint32_t                 swapchainCount;
  5.3575 -    const VkSwapchainKHR*    pSwapchains;
  5.3576 -    const uint32_t*          pImageIndices;
  5.3577 -    VkResult*                pResults;
  5.3578 -} VkPresentInfoKHR;
  5.3579 -
  5.3580 -
  5.3581 -typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
  5.3582 -typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
  5.3583 -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
  5.3584 -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
  5.3585 -typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
  5.3586 -
  5.3587 -#ifndef VK_NO_PROTOTYPES
  5.3588 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
  5.3589 -    VkDevice                                    device,
  5.3590 -    const VkSwapchainCreateInfoKHR*             pCreateInfo,
  5.3591 -    const VkAllocationCallbacks*                pAllocator,
  5.3592 -    VkSwapchainKHR*                             pSwapchain);
  5.3593 -
  5.3594 -VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
  5.3595 -    VkDevice                                    device,
  5.3596 -    VkSwapchainKHR                              swapchain,
  5.3597 -    const VkAllocationCallbacks*                pAllocator);
  5.3598 -
  5.3599 -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
  5.3600 -    VkDevice                                    device,
  5.3601 -    VkSwapchainKHR                              swapchain,
  5.3602 -    uint32_t*                                   pSwapchainImageCount,
  5.3603 -    VkImage*                                    pSwapchainImages);
  5.3604 -
  5.3605 -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
  5.3606 -    VkDevice                                    device,
  5.3607 -    VkSwapchainKHR                              swapchain,
  5.3608 -    uint64_t                                    timeout,
  5.3609 -    VkSemaphore                                 semaphore,
  5.3610 -    VkFence                                     fence,
  5.3611 -    uint32_t*                                   pImageIndex);
  5.3612 -
  5.3613 -VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
  5.3614 -    VkQueue                                     queue,
  5.3615 -    const VkPresentInfoKHR*                     pPresentInfo);
  5.3616 -#endif
  5.3617 -
  5.3618 -#define VK_KHR_display 1
  5.3619 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
  5.3620 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
  5.3621 -
  5.3622 -#define VK_KHR_DISPLAY_SPEC_VERSION       21
  5.3623 -#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
  5.3624 -
  5.3625 -
  5.3626 -typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
  5.3627 -    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
  5.3628 -    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
  5.3629 -    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
  5.3630 -    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
  5.3631 -    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.3632 -} VkDisplayPlaneAlphaFlagBitsKHR;
  5.3633 -typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
  5.3634 -typedef VkFlags VkDisplayModeCreateFlagsKHR;
  5.3635 -typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
  5.3636 -
  5.3637 -typedef struct VkDisplayPropertiesKHR {
  5.3638 -    VkDisplayKHR                  display;
  5.3639 -    const char*                   displayName;
  5.3640 -    VkExtent2D                    physicalDimensions;
  5.3641 -    VkExtent2D                    physicalResolution;
  5.3642 -    VkSurfaceTransformFlagsKHR    supportedTransforms;
  5.3643 -    VkBool32                      planeReorderPossible;
  5.3644 -    VkBool32                      persistentContent;
  5.3645 -} VkDisplayPropertiesKHR;
  5.3646 -
  5.3647 -typedef struct VkDisplayModeParametersKHR {
  5.3648 -    VkExtent2D    visibleRegion;
  5.3649 -    uint32_t      refreshRate;
  5.3650 -} VkDisplayModeParametersKHR;
  5.3651 -
  5.3652 -typedef struct VkDisplayModePropertiesKHR {
  5.3653 -    VkDisplayModeKHR              displayMode;
  5.3654 -    VkDisplayModeParametersKHR    parameters;
  5.3655 -} VkDisplayModePropertiesKHR;
  5.3656 -
  5.3657 -typedef struct VkDisplayModeCreateInfoKHR {
  5.3658 -    VkStructureType                sType;
  5.3659 -    const void*                    pNext;
  5.3660 -    VkDisplayModeCreateFlagsKHR    flags;
  5.3661 -    VkDisplayModeParametersKHR     parameters;
  5.3662 -} VkDisplayModeCreateInfoKHR;
  5.3663 -
  5.3664 -typedef struct VkDisplayPlaneCapabilitiesKHR {
  5.3665 -    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
  5.3666 -    VkOffset2D                     minSrcPosition;
  5.3667 -    VkOffset2D                     maxSrcPosition;
  5.3668 -    VkExtent2D                     minSrcExtent;
  5.3669 -    VkExtent2D                     maxSrcExtent;
  5.3670 -    VkOffset2D                     minDstPosition;
  5.3671 -    VkOffset2D                     maxDstPosition;
  5.3672 -    VkExtent2D                     minDstExtent;
  5.3673 -    VkExtent2D                     maxDstExtent;
  5.3674 -} VkDisplayPlaneCapabilitiesKHR;
  5.3675 -
  5.3676 -typedef struct VkDisplayPlanePropertiesKHR {
  5.3677 -    VkDisplayKHR    currentDisplay;
  5.3678 -    uint32_t        currentStackIndex;
  5.3679 -} VkDisplayPlanePropertiesKHR;
  5.3680 -
  5.3681 -typedef struct VkDisplaySurfaceCreateInfoKHR {
  5.3682 -    VkStructureType                   sType;
  5.3683 -    const void*                       pNext;
  5.3684 -    VkDisplaySurfaceCreateFlagsKHR    flags;
  5.3685 -    VkDisplayModeKHR                  displayMode;
  5.3686 -    uint32_t                          planeIndex;
  5.3687 -    uint32_t                          planeStackIndex;
  5.3688 -    VkSurfaceTransformFlagBitsKHR     transform;
  5.3689 -    float                             globalAlpha;
  5.3690 -    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
  5.3691 -    VkExtent2D                        imageExtent;
  5.3692 -} VkDisplaySurfaceCreateInfoKHR;
  5.3693 -
  5.3694 -
  5.3695 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
  5.3696 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
  5.3697 -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
  5.3698 -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
  5.3699 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
  5.3700 -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
  5.3701 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3702 -
  5.3703 -#ifndef VK_NO_PROTOTYPES
  5.3704 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
  5.3705 -    VkPhysicalDevice                            physicalDevice,
  5.3706 -    uint32_t*                                   pPropertyCount,
  5.3707 -    VkDisplayPropertiesKHR*                     pProperties);
  5.3708 -
  5.3709 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
  5.3710 -    VkPhysicalDevice                            physicalDevice,
  5.3711 -    uint32_t*                                   pPropertyCount,
  5.3712 -    VkDisplayPlanePropertiesKHR*                pProperties);
  5.3713 -
  5.3714 -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
  5.3715 -    VkPhysicalDevice                            physicalDevice,
  5.3716 -    uint32_t                                    planeIndex,
  5.3717 -    uint32_t*                                   pDisplayCount,
  5.3718 -    VkDisplayKHR*                               pDisplays);
  5.3719 -
  5.3720 -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
  5.3721 -    VkPhysicalDevice                            physicalDevice,
  5.3722 -    VkDisplayKHR                                display,
  5.3723 -    uint32_t*                                   pPropertyCount,
  5.3724 -    VkDisplayModePropertiesKHR*                 pProperties);
  5.3725 -
  5.3726 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
  5.3727 -    VkPhysicalDevice                            physicalDevice,
  5.3728 -    VkDisplayKHR                                display,
  5.3729 -    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
  5.3730 -    const VkAllocationCallbacks*                pAllocator,
  5.3731 -    VkDisplayModeKHR*                           pMode);
  5.3732 -
  5.3733 -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
  5.3734 -    VkPhysicalDevice                            physicalDevice,
  5.3735 -    VkDisplayModeKHR                            mode,
  5.3736 -    uint32_t                                    planeIndex,
  5.3737 -    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
  5.3738 -
  5.3739 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
  5.3740 -    VkInstance                                  instance,
  5.3741 -    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
  5.3742 -    const VkAllocationCallbacks*                pAllocator,
  5.3743 -    VkSurfaceKHR*                               pSurface);
  5.3744 -#endif
  5.3745 -
  5.3746 -#define VK_KHR_display_swapchain 1
  5.3747 -#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
  5.3748 -#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
  5.3749 -
  5.3750 -typedef struct VkDisplayPresentInfoKHR {
  5.3751 -    VkStructureType    sType;
  5.3752 -    const void*        pNext;
  5.3753 -    VkRect2D           srcRect;
  5.3754 -    VkRect2D           dstRect;
  5.3755 -    VkBool32           persistent;
  5.3756 -} VkDisplayPresentInfoKHR;
  5.3757 -
  5.3758 -
  5.3759 -typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
  5.3760 -
  5.3761 -#ifndef VK_NO_PROTOTYPES
  5.3762 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
  5.3763 -    VkDevice                                    device,
  5.3764 -    uint32_t                                    swapchainCount,
  5.3765 -    const VkSwapchainCreateInfoKHR*             pCreateInfos,
  5.3766 -    const VkAllocationCallbacks*                pAllocator,
  5.3767 -    VkSwapchainKHR*                             pSwapchains);
  5.3768 -#endif
  5.3769 -
  5.3770 -#ifdef VK_USE_PLATFORM_XLIB_KHR
  5.3771 -#define VK_KHR_xlib_surface 1
  5.3772 -#include <X11/Xlib.h>
  5.3773 -
  5.3774 -#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
  5.3775 -#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
  5.3776 -
  5.3777 -typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
  5.3778 -
  5.3779 -typedef struct VkXlibSurfaceCreateInfoKHR {
  5.3780 -    VkStructureType                sType;
  5.3781 -    const void*                    pNext;
  5.3782 -    VkXlibSurfaceCreateFlagsKHR    flags;
  5.3783 -    Display*                       dpy;
  5.3784 -    Window                         window;
  5.3785 -} VkXlibSurfaceCreateInfoKHR;
  5.3786 -
  5.3787 -
  5.3788 -typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3789 -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
  5.3790 -
  5.3791 -#ifndef VK_NO_PROTOTYPES
  5.3792 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
  5.3793 -    VkInstance                                  instance,
  5.3794 -    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
  5.3795 -    const VkAllocationCallbacks*                pAllocator,
  5.3796 -    VkSurfaceKHR*                               pSurface);
  5.3797 -
  5.3798 -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
  5.3799 -    VkPhysicalDevice                            physicalDevice,
  5.3800 -    uint32_t                                    queueFamilyIndex,
  5.3801 -    Display*                                    dpy,
  5.3802 -    VisualID                                    visualID);
  5.3803 -#endif
  5.3804 -#endif /* VK_USE_PLATFORM_XLIB_KHR */
  5.3805 -
  5.3806 -#ifdef VK_USE_PLATFORM_XCB_KHR
  5.3807 -#define VK_KHR_xcb_surface 1
  5.3808 -#include <xcb/xcb.h>
  5.3809 -
  5.3810 -#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
  5.3811 -#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
  5.3812 -
  5.3813 -typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
  5.3814 -
  5.3815 -typedef struct VkXcbSurfaceCreateInfoKHR {
  5.3816 -    VkStructureType               sType;
  5.3817 -    const void*                   pNext;
  5.3818 -    VkXcbSurfaceCreateFlagsKHR    flags;
  5.3819 -    xcb_connection_t*             connection;
  5.3820 -    xcb_window_t                  window;
  5.3821 -} VkXcbSurfaceCreateInfoKHR;
  5.3822 -
  5.3823 -
  5.3824 -typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3825 -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
  5.3826 -
  5.3827 -#ifndef VK_NO_PROTOTYPES
  5.3828 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
  5.3829 -    VkInstance                                  instance,
  5.3830 -    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
  5.3831 -    const VkAllocationCallbacks*                pAllocator,
  5.3832 -    VkSurfaceKHR*                               pSurface);
  5.3833 -
  5.3834 -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
  5.3835 -    VkPhysicalDevice                            physicalDevice,
  5.3836 -    uint32_t                                    queueFamilyIndex,
  5.3837 -    xcb_connection_t*                           connection,
  5.3838 -    xcb_visualid_t                              visual_id);
  5.3839 -#endif
  5.3840 -#endif /* VK_USE_PLATFORM_XCB_KHR */
  5.3841 -
  5.3842 -#ifdef VK_USE_PLATFORM_WAYLAND_KHR
  5.3843 -#define VK_KHR_wayland_surface 1
  5.3844 -#include <wayland-client.h>
  5.3845 -
  5.3846 -#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
  5.3847 -#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
  5.3848 -
  5.3849 -typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
  5.3850 -
  5.3851 -typedef struct VkWaylandSurfaceCreateInfoKHR {
  5.3852 -    VkStructureType                   sType;
  5.3853 -    const void*                       pNext;
  5.3854 -    VkWaylandSurfaceCreateFlagsKHR    flags;
  5.3855 -    struct wl_display*                display;
  5.3856 -    struct wl_surface*                surface;
  5.3857 -} VkWaylandSurfaceCreateInfoKHR;
  5.3858 -
  5.3859 -
  5.3860 -typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3861 -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
  5.3862 -
  5.3863 -#ifndef VK_NO_PROTOTYPES
  5.3864 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
  5.3865 -    VkInstance                                  instance,
  5.3866 -    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
  5.3867 -    const VkAllocationCallbacks*                pAllocator,
  5.3868 -    VkSurfaceKHR*                               pSurface);
  5.3869 -
  5.3870 -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
  5.3871 -    VkPhysicalDevice                            physicalDevice,
  5.3872 -    uint32_t                                    queueFamilyIndex,
  5.3873 -    struct wl_display*                          display);
  5.3874 -#endif
  5.3875 -#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
  5.3876 -
  5.3877 -#ifdef VK_USE_PLATFORM_MIR_KHR
  5.3878 -#define VK_KHR_mir_surface 1
  5.3879 -#include <mir_toolkit/client_types.h>
  5.3880 -
  5.3881 -#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
  5.3882 -#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
  5.3883 -
  5.3884 -typedef VkFlags VkMirSurfaceCreateFlagsKHR;
  5.3885 -
  5.3886 -typedef struct VkMirSurfaceCreateInfoKHR {
  5.3887 -    VkStructureType               sType;
  5.3888 -    const void*                   pNext;
  5.3889 -    VkMirSurfaceCreateFlagsKHR    flags;
  5.3890 -    MirConnection*                connection;
  5.3891 -    MirSurface*                   mirSurface;
  5.3892 -} VkMirSurfaceCreateInfoKHR;
  5.3893 -
  5.3894 -
  5.3895 -typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3896 -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
  5.3897 -
  5.3898 -#ifndef VK_NO_PROTOTYPES
  5.3899 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
  5.3900 -    VkInstance                                  instance,
  5.3901 -    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
  5.3902 -    const VkAllocationCallbacks*                pAllocator,
  5.3903 -    VkSurfaceKHR*                               pSurface);
  5.3904 -
  5.3905 -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
  5.3906 -    VkPhysicalDevice                            physicalDevice,
  5.3907 -    uint32_t                                    queueFamilyIndex,
  5.3908 -    MirConnection*                              connection);
  5.3909 -#endif
  5.3910 -#endif /* VK_USE_PLATFORM_MIR_KHR */
  5.3911 -
  5.3912 -#ifdef VK_USE_PLATFORM_ANDROID_KHR
  5.3913 -#define VK_KHR_android_surface 1
  5.3914 -#include <android/native_window.h>
  5.3915 -
  5.3916 -#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
  5.3917 -#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
  5.3918 -
  5.3919 -typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
  5.3920 -
  5.3921 -typedef struct VkAndroidSurfaceCreateInfoKHR {
  5.3922 -    VkStructureType                   sType;
  5.3923 -    const void*                       pNext;
  5.3924 -    VkAndroidSurfaceCreateFlagsKHR    flags;
  5.3925 -    ANativeWindow*                    window;
  5.3926 -} VkAndroidSurfaceCreateInfoKHR;
  5.3927 -
  5.3928 -
  5.3929 -typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3930 -
  5.3931 -#ifndef VK_NO_PROTOTYPES
  5.3932 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
  5.3933 -    VkInstance                                  instance,
  5.3934 -    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
  5.3935 -    const VkAllocationCallbacks*                pAllocator,
  5.3936 -    VkSurfaceKHR*                               pSurface);
  5.3937 -#endif
  5.3938 -#endif /* VK_USE_PLATFORM_ANDROID_KHR */
  5.3939 -
  5.3940 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.3941 -#define VK_KHR_win32_surface 1
  5.3942 -#include <windows.h>
  5.3943 -
  5.3944 -#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
  5.3945 -#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
  5.3946 -
  5.3947 -typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
  5.3948 -
  5.3949 -typedef struct VkWin32SurfaceCreateInfoKHR {
  5.3950 -    VkStructureType                 sType;
  5.3951 -    const void*                     pNext;
  5.3952 -    VkWin32SurfaceCreateFlagsKHR    flags;
  5.3953 -    HINSTANCE                       hinstance;
  5.3954 -    HWND                            hwnd;
  5.3955 -} VkWin32SurfaceCreateInfoKHR;
  5.3956 -
  5.3957 -
  5.3958 -typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.3959 -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
  5.3960 -
  5.3961 -#ifndef VK_NO_PROTOTYPES
  5.3962 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
  5.3963 -    VkInstance                                  instance,
  5.3964 -    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
  5.3965 -    const VkAllocationCallbacks*                pAllocator,
  5.3966 -    VkSurfaceKHR*                               pSurface);
  5.3967 -
  5.3968 -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
  5.3969 -    VkPhysicalDevice                            physicalDevice,
  5.3970 -    uint32_t                                    queueFamilyIndex);
  5.3971 -#endif
  5.3972 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.3973 -
  5.3974 -#define VK_KHR_sampler_mirror_clamp_to_edge 1
  5.3975 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
  5.3976 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
  5.3977 -
  5.3978 -
  5.3979 -#define VK_KHR_get_physical_device_properties2 1
  5.3980 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
  5.3981 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
  5.3982 -
  5.3983 -typedef struct VkPhysicalDeviceFeatures2KHR {
  5.3984 -    VkStructureType             sType;
  5.3985 -    void*                       pNext;
  5.3986 -    VkPhysicalDeviceFeatures    features;
  5.3987 -} VkPhysicalDeviceFeatures2KHR;
  5.3988 -
  5.3989 -typedef struct VkPhysicalDeviceProperties2KHR {
  5.3990 -    VkStructureType               sType;
  5.3991 -    void*                         pNext;
  5.3992 -    VkPhysicalDeviceProperties    properties;
  5.3993 -} VkPhysicalDeviceProperties2KHR;
  5.3994 -
  5.3995 -typedef struct VkFormatProperties2KHR {
  5.3996 -    VkStructureType       sType;
  5.3997 -    void*                 pNext;
  5.3998 -    VkFormatProperties    formatProperties;
  5.3999 -} VkFormatProperties2KHR;
  5.4000 -
  5.4001 -typedef struct VkImageFormatProperties2KHR {
  5.4002 -    VkStructureType            sType;
  5.4003 -    void*                      pNext;
  5.4004 -    VkImageFormatProperties    imageFormatProperties;
  5.4005 -} VkImageFormatProperties2KHR;
  5.4006 -
  5.4007 -typedef struct VkPhysicalDeviceImageFormatInfo2KHR {
  5.4008 -    VkStructureType       sType;
  5.4009 -    const void*           pNext;
  5.4010 -    VkFormat              format;
  5.4011 -    VkImageType           type;
  5.4012 -    VkImageTiling         tiling;
  5.4013 -    VkImageUsageFlags     usage;
  5.4014 -    VkImageCreateFlags    flags;
  5.4015 -} VkPhysicalDeviceImageFormatInfo2KHR;
  5.4016 -
  5.4017 -typedef struct VkQueueFamilyProperties2KHR {
  5.4018 -    VkStructureType            sType;
  5.4019 -    void*                      pNext;
  5.4020 -    VkQueueFamilyProperties    queueFamilyProperties;
  5.4021 -} VkQueueFamilyProperties2KHR;
  5.4022 -
  5.4023 -typedef struct VkPhysicalDeviceMemoryProperties2KHR {
  5.4024 -    VkStructureType                     sType;
  5.4025 -    void*                               pNext;
  5.4026 -    VkPhysicalDeviceMemoryProperties    memoryProperties;
  5.4027 -} VkPhysicalDeviceMemoryProperties2KHR;
  5.4028 -
  5.4029 -typedef struct VkSparseImageFormatProperties2KHR {
  5.4030 -    VkStructureType                  sType;
  5.4031 -    void*                            pNext;
  5.4032 -    VkSparseImageFormatProperties    properties;
  5.4033 -} VkSparseImageFormatProperties2KHR;
  5.4034 -
  5.4035 -typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
  5.4036 -    VkStructureType          sType;
  5.4037 -    const void*              pNext;
  5.4038 -    VkFormat                 format;
  5.4039 -    VkImageType              type;
  5.4040 -    VkSampleCountFlagBits    samples;
  5.4041 -    VkImageUsageFlags        usage;
  5.4042 -    VkImageTiling            tiling;
  5.4043 -} VkPhysicalDeviceSparseImageFormatInfo2KHR;
  5.4044 -
  5.4045 -
  5.4046 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
  5.4047 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
  5.4048 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
  5.4049 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
  5.4050 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
  5.4051 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
  5.4052 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
  5.4053 -
  5.4054 -#ifndef VK_NO_PROTOTYPES
  5.4055 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
  5.4056 -    VkPhysicalDevice                            physicalDevice,
  5.4057 -    VkPhysicalDeviceFeatures2KHR*               pFeatures);
  5.4058 -
  5.4059 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
  5.4060 -    VkPhysicalDevice                            physicalDevice,
  5.4061 -    VkPhysicalDeviceProperties2KHR*             pProperties);
  5.4062 -
  5.4063 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
  5.4064 -    VkPhysicalDevice                            physicalDevice,
  5.4065 -    VkFormat                                    format,
  5.4066 -    VkFormatProperties2KHR*                     pFormatProperties);
  5.4067 -
  5.4068 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
  5.4069 -    VkPhysicalDevice                            physicalDevice,
  5.4070 -    const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
  5.4071 -    VkImageFormatProperties2KHR*                pImageFormatProperties);
  5.4072 -
  5.4073 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
  5.4074 -    VkPhysicalDevice                            physicalDevice,
  5.4075 -    uint32_t*                                   pQueueFamilyPropertyCount,
  5.4076 -    VkQueueFamilyProperties2KHR*                pQueueFamilyProperties);
  5.4077 -
  5.4078 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
  5.4079 -    VkPhysicalDevice                            physicalDevice,
  5.4080 -    VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties);
  5.4081 -
  5.4082 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
  5.4083 -    VkPhysicalDevice                            physicalDevice,
  5.4084 -    const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
  5.4085 -    uint32_t*                                   pPropertyCount,
  5.4086 -    VkSparseImageFormatProperties2KHR*          pProperties);
  5.4087 -#endif
  5.4088 -
  5.4089 -#define VK_KHR_shader_draw_parameters 1
  5.4090 -#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
  5.4091 -#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
  5.4092 -
  5.4093 -
  5.4094 -#define VK_KHR_maintenance1 1
  5.4095 -#define VK_KHR_MAINTENANCE1_SPEC_VERSION  1
  5.4096 -#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
  5.4097 -
  5.4098 -typedef VkFlags VkCommandPoolTrimFlagsKHR;
  5.4099 -
  5.4100 -typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
  5.4101 -
  5.4102 -#ifndef VK_NO_PROTOTYPES
  5.4103 -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
  5.4104 -    VkDevice                                    device,
  5.4105 -    VkCommandPool                               commandPool,
  5.4106 -    VkCommandPoolTrimFlagsKHR                   flags);
  5.4107 -#endif
  5.4108 -
  5.4109 -#define VK_KHR_external_memory_capabilities 1
  5.4110 -#define VK_LUID_SIZE_KHR                  8
  5.4111 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
  5.4112 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
  5.4113 -
  5.4114 -
  5.4115 -typedef enum VkExternalMemoryHandleTypeFlagBitsKHR {
  5.4116 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
  5.4117 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
  5.4118 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
  5.4119 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008,
  5.4120 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010,
  5.4121 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020,
  5.4122 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040,
  5.4123 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4124 -} VkExternalMemoryHandleTypeFlagBitsKHR;
  5.4125 -typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR;
  5.4126 -
  5.4127 -typedef enum VkExternalMemoryFeatureFlagBitsKHR {
  5.4128 -    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001,
  5.4129 -    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002,
  5.4130 -    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004,
  5.4131 -    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4132 -} VkExternalMemoryFeatureFlagBitsKHR;
  5.4133 -typedef VkFlags VkExternalMemoryFeatureFlagsKHR;
  5.4134 -
  5.4135 -typedef struct VkExternalMemoryPropertiesKHR {
  5.4136 -    VkExternalMemoryFeatureFlagsKHR       externalMemoryFeatures;
  5.4137 -    VkExternalMemoryHandleTypeFlagsKHR    exportFromImportedHandleTypes;
  5.4138 -    VkExternalMemoryHandleTypeFlagsKHR    compatibleHandleTypes;
  5.4139 -} VkExternalMemoryPropertiesKHR;
  5.4140 -
  5.4141 -typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR {
  5.4142 -    VkStructureType                          sType;
  5.4143 -    const void*                              pNext;
  5.4144 -    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  5.4145 -} VkPhysicalDeviceExternalImageFormatInfoKHR;
  5.4146 -
  5.4147 -typedef struct VkExternalImageFormatPropertiesKHR {
  5.4148 -    VkStructureType                  sType;
  5.4149 -    void*                            pNext;
  5.4150 -    VkExternalMemoryPropertiesKHR    externalMemoryProperties;
  5.4151 -} VkExternalImageFormatPropertiesKHR;
  5.4152 -
  5.4153 -typedef struct VkPhysicalDeviceExternalBufferInfoKHR {
  5.4154 -    VkStructureType                          sType;
  5.4155 -    const void*                              pNext;
  5.4156 -    VkBufferCreateFlags                      flags;
  5.4157 -    VkBufferUsageFlags                       usage;
  5.4158 -    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  5.4159 -} VkPhysicalDeviceExternalBufferInfoKHR;
  5.4160 -
  5.4161 -typedef struct VkExternalBufferPropertiesKHR {
  5.4162 -    VkStructureType                  sType;
  5.4163 -    void*                            pNext;
  5.4164 -    VkExternalMemoryPropertiesKHR    externalMemoryProperties;
  5.4165 -} VkExternalBufferPropertiesKHR;
  5.4166 -
  5.4167 -typedef struct VkPhysicalDeviceIDPropertiesKHR {
  5.4168 -    VkStructureType    sType;
  5.4169 -    void*              pNext;
  5.4170 -    uint8_t            deviceUUID[VK_UUID_SIZE];
  5.4171 -    uint8_t            driverUUID[VK_UUID_SIZE];
  5.4172 -    uint8_t            deviceLUID[VK_LUID_SIZE_KHR];
  5.4173 -    uint32_t           deviceNodeMask;
  5.4174 -    VkBool32           deviceLUIDValid;
  5.4175 -} VkPhysicalDeviceIDPropertiesKHR;
  5.4176 -
  5.4177 -
  5.4178 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties);
  5.4179 -
  5.4180 -#ifndef VK_NO_PROTOTYPES
  5.4181 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
  5.4182 -    VkPhysicalDevice                            physicalDevice,
  5.4183 -    const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
  5.4184 -    VkExternalBufferPropertiesKHR*              pExternalBufferProperties);
  5.4185 -#endif
  5.4186 -
  5.4187 -#define VK_KHR_external_memory 1
  5.4188 -#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
  5.4189 -#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
  5.4190 -#define VK_QUEUE_FAMILY_EXTERNAL_KHR      (~0U-1)
  5.4191 -
  5.4192 -typedef struct VkExternalMemoryImageCreateInfoKHR {
  5.4193 -    VkStructureType                       sType;
  5.4194 -    const void*                           pNext;
  5.4195 -    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
  5.4196 -} VkExternalMemoryImageCreateInfoKHR;
  5.4197 -
  5.4198 -typedef struct VkExternalMemoryBufferCreateInfoKHR {
  5.4199 -    VkStructureType                       sType;
  5.4200 -    const void*                           pNext;
  5.4201 -    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
  5.4202 -} VkExternalMemoryBufferCreateInfoKHR;
  5.4203 -
  5.4204 -typedef struct VkExportMemoryAllocateInfoKHR {
  5.4205 -    VkStructureType                       sType;
  5.4206 -    const void*                           pNext;
  5.4207 -    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
  5.4208 -} VkExportMemoryAllocateInfoKHR;
  5.4209 -
  5.4210 -
  5.4211 -
  5.4212 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.4213 -#define VK_KHR_external_memory_win32 1
  5.4214 -#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
  5.4215 -#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
  5.4216 -
  5.4217 -typedef struct VkImportMemoryWin32HandleInfoKHR {
  5.4218 -    VkStructureType                          sType;
  5.4219 -    const void*                              pNext;
  5.4220 -    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  5.4221 -    HANDLE                                   handle;
  5.4222 -    LPCWSTR                                  name;
  5.4223 -} VkImportMemoryWin32HandleInfoKHR;
  5.4224 -
  5.4225 -typedef struct VkExportMemoryWin32HandleInfoKHR {
  5.4226 -    VkStructureType               sType;
  5.4227 -    const void*                   pNext;
  5.4228 -    const SECURITY_ATTRIBUTES*    pAttributes;
  5.4229 -    DWORD                         dwAccess;
  5.4230 -    LPCWSTR                       name;
  5.4231 -} VkExportMemoryWin32HandleInfoKHR;
  5.4232 -
  5.4233 -typedef struct VkMemoryWin32HandlePropertiesKHR {
  5.4234 -    VkStructureType    sType;
  5.4235 -    void*              pNext;
  5.4236 -    uint32_t           memoryTypeBits;
  5.4237 -} VkMemoryWin32HandlePropertiesKHR;
  5.4238 -
  5.4239 -typedef struct VkMemoryGetWin32HandleInfoKHR {
  5.4240 -    VkStructureType                          sType;
  5.4241 -    const void*                              pNext;
  5.4242 -    VkDeviceMemory                           memory;
  5.4243 -    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  5.4244 -} VkMemoryGetWin32HandleInfoKHR;
  5.4245 -
  5.4246 -
  5.4247 -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
  5.4248 -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
  5.4249 -
  5.4250 -#ifndef VK_NO_PROTOTYPES
  5.4251 -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
  5.4252 -    VkDevice                                    device,
  5.4253 -    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
  5.4254 -    HANDLE*                                     pHandle);
  5.4255 -
  5.4256 -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
  5.4257 -    VkDevice                                    device,
  5.4258 -    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
  5.4259 -    HANDLE                                      handle,
  5.4260 -    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
  5.4261 -#endif
  5.4262 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.4263 -
  5.4264 -#define VK_KHR_external_memory_fd 1
  5.4265 -#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
  5.4266 -#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
  5.4267 -
  5.4268 -typedef struct VkImportMemoryFdInfoKHR {
  5.4269 -    VkStructureType                          sType;
  5.4270 -    const void*                              pNext;
  5.4271 -    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  5.4272 -    int                                      fd;
  5.4273 -} VkImportMemoryFdInfoKHR;
  5.4274 -
  5.4275 -typedef struct VkMemoryFdPropertiesKHR {
  5.4276 -    VkStructureType    sType;
  5.4277 -    void*              pNext;
  5.4278 -    uint32_t           memoryTypeBits;
  5.4279 -} VkMemoryFdPropertiesKHR;
  5.4280 -
  5.4281 -typedef struct VkMemoryGetFdInfoKHR {
  5.4282 -    VkStructureType                          sType;
  5.4283 -    const void*                              pNext;
  5.4284 -    VkDeviceMemory                           memory;
  5.4285 -    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
  5.4286 -} VkMemoryGetFdInfoKHR;
  5.4287 -
  5.4288 -
  5.4289 -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
  5.4290 -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
  5.4291 -
  5.4292 -#ifndef VK_NO_PROTOTYPES
  5.4293 -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
  5.4294 -    VkDevice                                    device,
  5.4295 -    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
  5.4296 -    int*                                        pFd);
  5.4297 -
  5.4298 -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
  5.4299 -    VkDevice                                    device,
  5.4300 -    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
  5.4301 -    int                                         fd,
  5.4302 -    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
  5.4303 -#endif
  5.4304 -
  5.4305 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.4306 -#define VK_KHR_win32_keyed_mutex 1
  5.4307 -#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
  5.4308 -#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
  5.4309 -
  5.4310 -typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
  5.4311 -    VkStructureType          sType;
  5.4312 -    const void*              pNext;
  5.4313 -    uint32_t                 acquireCount;
  5.4314 -    const VkDeviceMemory*    pAcquireSyncs;
  5.4315 -    const uint64_t*          pAcquireKeys;
  5.4316 -    const uint32_t*          pAcquireTimeouts;
  5.4317 -    uint32_t                 releaseCount;
  5.4318 -    const VkDeviceMemory*    pReleaseSyncs;
  5.4319 -    const uint64_t*          pReleaseKeys;
  5.4320 -} VkWin32KeyedMutexAcquireReleaseInfoKHR;
  5.4321 -
  5.4322 -
  5.4323 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.4324 -
  5.4325 -#define VK_KHR_external_semaphore_capabilities 1
  5.4326 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
  5.4327 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
  5.4328 -
  5.4329 -
  5.4330 -typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR {
  5.4331 -    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
  5.4332 -    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
  5.4333 -    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
  5.4334 -    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008,
  5.4335 -    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010,
  5.4336 -    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4337 -} VkExternalSemaphoreHandleTypeFlagBitsKHR;
  5.4338 -typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR;
  5.4339 -
  5.4340 -typedef enum VkExternalSemaphoreFeatureFlagBitsKHR {
  5.4341 -    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
  5.4342 -    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
  5.4343 -    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4344 -} VkExternalSemaphoreFeatureFlagBitsKHR;
  5.4345 -typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR;
  5.4346 -
  5.4347 -typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR {
  5.4348 -    VkStructureType                             sType;
  5.4349 -    const void*                                 pNext;
  5.4350 -    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  5.4351 -} VkPhysicalDeviceExternalSemaphoreInfoKHR;
  5.4352 -
  5.4353 -typedef struct VkExternalSemaphorePropertiesKHR {
  5.4354 -    VkStructureType                          sType;
  5.4355 -    void*                                    pNext;
  5.4356 -    VkExternalSemaphoreHandleTypeFlagsKHR    exportFromImportedHandleTypes;
  5.4357 -    VkExternalSemaphoreHandleTypeFlagsKHR    compatibleHandleTypes;
  5.4358 -    VkExternalSemaphoreFeatureFlagsKHR       externalSemaphoreFeatures;
  5.4359 -} VkExternalSemaphorePropertiesKHR;
  5.4360 -
  5.4361 -
  5.4362 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
  5.4363 -
  5.4364 -#ifndef VK_NO_PROTOTYPES
  5.4365 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
  5.4366 -    VkPhysicalDevice                            physicalDevice,
  5.4367 -    const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
  5.4368 -    VkExternalSemaphorePropertiesKHR*           pExternalSemaphoreProperties);
  5.4369 -#endif
  5.4370 -
  5.4371 -#define VK_KHR_external_semaphore 1
  5.4372 -#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
  5.4373 -#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
  5.4374 -
  5.4375 -
  5.4376 -typedef enum VkSemaphoreImportFlagBitsKHR {
  5.4377 -    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
  5.4378 -    VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4379 -} VkSemaphoreImportFlagBitsKHR;
  5.4380 -typedef VkFlags VkSemaphoreImportFlagsKHR;
  5.4381 -
  5.4382 -typedef struct VkExportSemaphoreCreateInfoKHR {
  5.4383 -    VkStructureType                          sType;
  5.4384 -    const void*                              pNext;
  5.4385 -    VkExternalSemaphoreHandleTypeFlagsKHR    handleTypes;
  5.4386 -} VkExportSemaphoreCreateInfoKHR;
  5.4387 -
  5.4388 -
  5.4389 -
  5.4390 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.4391 -#define VK_KHR_external_semaphore_win32 1
  5.4392 -#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
  5.4393 -#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
  5.4394 -
  5.4395 -typedef struct VkImportSemaphoreWin32HandleInfoKHR {
  5.4396 -    VkStructureType                             sType;
  5.4397 -    const void*                                 pNext;
  5.4398 -    VkSemaphore                                 semaphore;
  5.4399 -    VkSemaphoreImportFlagsKHR                   flags;
  5.4400 -    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  5.4401 -    HANDLE                                      handle;
  5.4402 -    LPCWSTR                                     name;
  5.4403 -} VkImportSemaphoreWin32HandleInfoKHR;
  5.4404 -
  5.4405 -typedef struct VkExportSemaphoreWin32HandleInfoKHR {
  5.4406 -    VkStructureType               sType;
  5.4407 -    const void*                   pNext;
  5.4408 -    const SECURITY_ATTRIBUTES*    pAttributes;
  5.4409 -    DWORD                         dwAccess;
  5.4410 -    LPCWSTR                       name;
  5.4411 -} VkExportSemaphoreWin32HandleInfoKHR;
  5.4412 -
  5.4413 -typedef struct VkD3D12FenceSubmitInfoKHR {
  5.4414 -    VkStructureType    sType;
  5.4415 -    const void*        pNext;
  5.4416 -    uint32_t           waitSemaphoreValuesCount;
  5.4417 -    const uint64_t*    pWaitSemaphoreValues;
  5.4418 -    uint32_t           signalSemaphoreValuesCount;
  5.4419 -    const uint64_t*    pSignalSemaphoreValues;
  5.4420 -} VkD3D12FenceSubmitInfoKHR;
  5.4421 -
  5.4422 -typedef struct VkSemaphoreGetWin32HandleInfoKHR {
  5.4423 -    VkStructureType                             sType;
  5.4424 -    const void*                                 pNext;
  5.4425 -    VkSemaphore                                 semaphore;
  5.4426 -    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  5.4427 -} VkSemaphoreGetWin32HandleInfoKHR;
  5.4428 -
  5.4429 -
  5.4430 -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
  5.4431 -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
  5.4432 -
  5.4433 -#ifndef VK_NO_PROTOTYPES
  5.4434 -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
  5.4435 -    VkDevice                                    device,
  5.4436 -    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
  5.4437 -
  5.4438 -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
  5.4439 -    VkDevice                                    device,
  5.4440 -    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
  5.4441 -    HANDLE*                                     pHandle);
  5.4442 -#endif
  5.4443 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.4444 -
  5.4445 -#define VK_KHR_external_semaphore_fd 1
  5.4446 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
  5.4447 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
  5.4448 -
  5.4449 -typedef struct VkImportSemaphoreFdInfoKHR {
  5.4450 -    VkStructureType                             sType;
  5.4451 -    const void*                                 pNext;
  5.4452 -    VkSemaphore                                 semaphore;
  5.4453 -    VkSemaphoreImportFlagsKHR                   flags;
  5.4454 -    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  5.4455 -    int                                         fd;
  5.4456 -} VkImportSemaphoreFdInfoKHR;
  5.4457 -
  5.4458 -typedef struct VkSemaphoreGetFdInfoKHR {
  5.4459 -    VkStructureType                             sType;
  5.4460 -    const void*                                 pNext;
  5.4461 -    VkSemaphore                                 semaphore;
  5.4462 -    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
  5.4463 -} VkSemaphoreGetFdInfoKHR;
  5.4464 -
  5.4465 -
  5.4466 -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
  5.4467 -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
  5.4468 -
  5.4469 -#ifndef VK_NO_PROTOTYPES
  5.4470 -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
  5.4471 -    VkDevice                                    device,
  5.4472 -    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
  5.4473 -
  5.4474 -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
  5.4475 -    VkDevice                                    device,
  5.4476 -    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
  5.4477 -    int*                                        pFd);
  5.4478 -#endif
  5.4479 -
  5.4480 -#define VK_KHR_push_descriptor 1
  5.4481 -#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
  5.4482 -#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
  5.4483 -
  5.4484 -typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
  5.4485 -    VkStructureType    sType;
  5.4486 -    void*              pNext;
  5.4487 -    uint32_t           maxPushDescriptors;
  5.4488 -} VkPhysicalDevicePushDescriptorPropertiesKHR;
  5.4489 -
  5.4490 -
  5.4491 -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
  5.4492 -
  5.4493 -#ifndef VK_NO_PROTOTYPES
  5.4494 -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
  5.4495 -    VkCommandBuffer                             commandBuffer,
  5.4496 -    VkPipelineBindPoint                         pipelineBindPoint,
  5.4497 -    VkPipelineLayout                            layout,
  5.4498 -    uint32_t                                    set,
  5.4499 -    uint32_t                                    descriptorWriteCount,
  5.4500 -    const VkWriteDescriptorSet*                 pDescriptorWrites);
  5.4501 -#endif
  5.4502 -
  5.4503 -#define VK_KHR_16bit_storage 1
  5.4504 -#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
  5.4505 -#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
  5.4506 -
  5.4507 -typedef struct VkPhysicalDevice16BitStorageFeaturesKHR {
  5.4508 -    VkStructureType    sType;
  5.4509 -    void*              pNext;
  5.4510 -    VkBool32           storageBuffer16BitAccess;
  5.4511 -    VkBool32           uniformAndStorageBuffer16BitAccess;
  5.4512 -    VkBool32           storagePushConstant16;
  5.4513 -    VkBool32           storageInputOutput16;
  5.4514 -} VkPhysicalDevice16BitStorageFeaturesKHR;
  5.4515 -
  5.4516 -
  5.4517 -
  5.4518 -#define VK_KHR_incremental_present 1
  5.4519 -#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
  5.4520 -#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
  5.4521 -
  5.4522 -typedef struct VkRectLayerKHR {
  5.4523 -    VkOffset2D    offset;
  5.4524 -    VkExtent2D    extent;
  5.4525 -    uint32_t      layer;
  5.4526 -} VkRectLayerKHR;
  5.4527 -
  5.4528 -typedef struct VkPresentRegionKHR {
  5.4529 -    uint32_t                 rectangleCount;
  5.4530 -    const VkRectLayerKHR*    pRectangles;
  5.4531 -} VkPresentRegionKHR;
  5.4532 -
  5.4533 -typedef struct VkPresentRegionsKHR {
  5.4534 -    VkStructureType              sType;
  5.4535 -    const void*                  pNext;
  5.4536 -    uint32_t                     swapchainCount;
  5.4537 -    const VkPresentRegionKHR*    pRegions;
  5.4538 -} VkPresentRegionsKHR;
  5.4539 -
  5.4540 -
  5.4541 -
  5.4542 -#define VK_KHR_descriptor_update_template 1
  5.4543 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
  5.4544 -
  5.4545 -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
  5.4546 -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
  5.4547 -
  5.4548 -
  5.4549 -typedef enum VkDescriptorUpdateTemplateTypeKHR {
  5.4550 -    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
  5.4551 -    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
  5.4552 -    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
  5.4553 -    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
  5.4554 -    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),
  5.4555 -    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4556 -} VkDescriptorUpdateTemplateTypeKHR;
  5.4557 -
  5.4558 -typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
  5.4559 -
  5.4560 -typedef struct VkDescriptorUpdateTemplateEntryKHR {
  5.4561 -    uint32_t            dstBinding;
  5.4562 -    uint32_t            dstArrayElement;
  5.4563 -    uint32_t            descriptorCount;
  5.4564 -    VkDescriptorType    descriptorType;
  5.4565 -    size_t              offset;
  5.4566 -    size_t              stride;
  5.4567 -} VkDescriptorUpdateTemplateEntryKHR;
  5.4568 -
  5.4569 -typedef struct VkDescriptorUpdateTemplateCreateInfoKHR {
  5.4570 -    VkStructureType                              sType;
  5.4571 -    void*                                        pNext;
  5.4572 -    VkDescriptorUpdateTemplateCreateFlagsKHR     flags;
  5.4573 -    uint32_t                                     descriptorUpdateEntryCount;
  5.4574 -    const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries;
  5.4575 -    VkDescriptorUpdateTemplateTypeKHR            templateType;
  5.4576 -    VkDescriptorSetLayout                        descriptorSetLayout;
  5.4577 -    VkPipelineBindPoint                          pipelineBindPoint;
  5.4578 -    VkPipelineLayout                             pipelineLayout;
  5.4579 -    uint32_t                                     set;
  5.4580 -} VkDescriptorUpdateTemplateCreateInfoKHR;
  5.4581 -
  5.4582 -
  5.4583 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
  5.4584 -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
  5.4585 -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
  5.4586 -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
  5.4587 -
  5.4588 -#ifndef VK_NO_PROTOTYPES
  5.4589 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
  5.4590 -    VkDevice                                    device,
  5.4591 -    const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
  5.4592 -    const VkAllocationCallbacks*                pAllocator,
  5.4593 -    VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate);
  5.4594 -
  5.4595 -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
  5.4596 -    VkDevice                                    device,
  5.4597 -    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
  5.4598 -    const VkAllocationCallbacks*                pAllocator);
  5.4599 -
  5.4600 -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
  5.4601 -    VkDevice                                    device,
  5.4602 -    VkDescriptorSet                             descriptorSet,
  5.4603 -    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
  5.4604 -    const void*                                 pData);
  5.4605 -
  5.4606 -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
  5.4607 -    VkCommandBuffer                             commandBuffer,
  5.4608 -    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
  5.4609 -    VkPipelineLayout                            layout,
  5.4610 -    uint32_t                                    set,
  5.4611 -    const void*                                 pData);
  5.4612 -#endif
  5.4613 -
  5.4614 -#define VK_KHR_shared_presentable_image 1
  5.4615 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
  5.4616 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
  5.4617 -
  5.4618 -typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
  5.4619 -    VkStructureType      sType;
  5.4620 -    void*                pNext;
  5.4621 -    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
  5.4622 -} VkSharedPresentSurfaceCapabilitiesKHR;
  5.4623 -
  5.4624 -
  5.4625 -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
  5.4626 -
  5.4627 -#ifndef VK_NO_PROTOTYPES
  5.4628 -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
  5.4629 -    VkDevice                                    device,
  5.4630 -    VkSwapchainKHR                              swapchain);
  5.4631 -#endif
  5.4632 -
  5.4633 -#define VK_KHR_external_fence_capabilities 1
  5.4634 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
  5.4635 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
  5.4636 -
  5.4637 -
  5.4638 -typedef enum VkExternalFenceHandleTypeFlagBitsKHR {
  5.4639 -    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
  5.4640 -    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
  5.4641 -    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
  5.4642 -    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008,
  5.4643 -    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4644 -} VkExternalFenceHandleTypeFlagBitsKHR;
  5.4645 -typedef VkFlags VkExternalFenceHandleTypeFlagsKHR;
  5.4646 -
  5.4647 -typedef enum VkExternalFenceFeatureFlagBitsKHR {
  5.4648 -    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
  5.4649 -    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
  5.4650 -    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4651 -} VkExternalFenceFeatureFlagBitsKHR;
  5.4652 -typedef VkFlags VkExternalFenceFeatureFlagsKHR;
  5.4653 -
  5.4654 -typedef struct VkPhysicalDeviceExternalFenceInfoKHR {
  5.4655 -    VkStructureType                         sType;
  5.4656 -    const void*                             pNext;
  5.4657 -    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  5.4658 -} VkPhysicalDeviceExternalFenceInfoKHR;
  5.4659 -
  5.4660 -typedef struct VkExternalFencePropertiesKHR {
  5.4661 -    VkStructureType                      sType;
  5.4662 -    void*                                pNext;
  5.4663 -    VkExternalFenceHandleTypeFlagsKHR    exportFromImportedHandleTypes;
  5.4664 -    VkExternalFenceHandleTypeFlagsKHR    compatibleHandleTypes;
  5.4665 -    VkExternalFenceFeatureFlagsKHR       externalFenceFeatures;
  5.4666 -} VkExternalFencePropertiesKHR;
  5.4667 -
  5.4668 -
  5.4669 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties);
  5.4670 -
  5.4671 -#ifndef VK_NO_PROTOTYPES
  5.4672 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
  5.4673 -    VkPhysicalDevice                            physicalDevice,
  5.4674 -    const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
  5.4675 -    VkExternalFencePropertiesKHR*               pExternalFenceProperties);
  5.4676 -#endif
  5.4677 -
  5.4678 -#define VK_KHR_external_fence 1
  5.4679 -#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
  5.4680 -#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
  5.4681 -
  5.4682 -
  5.4683 -typedef enum VkFenceImportFlagBitsKHR {
  5.4684 -    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
  5.4685 -    VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
  5.4686 -} VkFenceImportFlagBitsKHR;
  5.4687 -typedef VkFlags VkFenceImportFlagsKHR;
  5.4688 -
  5.4689 -typedef struct VkExportFenceCreateInfoKHR {
  5.4690 -    VkStructureType                      sType;
  5.4691 -    const void*                          pNext;
  5.4692 -    VkExternalFenceHandleTypeFlagsKHR    handleTypes;
  5.4693 -} VkExportFenceCreateInfoKHR;
  5.4694 -
  5.4695 -
  5.4696 -
  5.4697 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.4698 -#define VK_KHR_external_fence_win32 1
  5.4699 -#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
  5.4700 -#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
  5.4701 -
  5.4702 -typedef struct VkImportFenceWin32HandleInfoKHR {
  5.4703 -    VkStructureType                         sType;
  5.4704 -    const void*                             pNext;
  5.4705 -    VkFence                                 fence;
  5.4706 -    VkFenceImportFlagsKHR                   flags;
  5.4707 -    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  5.4708 -    HANDLE                                  handle;
  5.4709 -    LPCWSTR                                 name;
  5.4710 -} VkImportFenceWin32HandleInfoKHR;
  5.4711 -
  5.4712 -typedef struct VkExportFenceWin32HandleInfoKHR {
  5.4713 -    VkStructureType               sType;
  5.4714 -    const void*                   pNext;
  5.4715 -    const SECURITY_ATTRIBUTES*    pAttributes;
  5.4716 -    DWORD                         dwAccess;
  5.4717 -    LPCWSTR                       name;
  5.4718 -} VkExportFenceWin32HandleInfoKHR;
  5.4719 -
  5.4720 -typedef struct VkFenceGetWin32HandleInfoKHR {
  5.4721 -    VkStructureType                         sType;
  5.4722 -    const void*                             pNext;
  5.4723 -    VkFence                                 fence;
  5.4724 -    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  5.4725 -} VkFenceGetWin32HandleInfoKHR;
  5.4726 -
  5.4727 -
  5.4728 -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
  5.4729 -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
  5.4730 -
  5.4731 -#ifndef VK_NO_PROTOTYPES
  5.4732 -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
  5.4733 -    VkDevice                                    device,
  5.4734 -    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
  5.4735 -
  5.4736 -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
  5.4737 -    VkDevice                                    device,
  5.4738 -    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
  5.4739 -    HANDLE*                                     pHandle);
  5.4740 -#endif
  5.4741 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.4742 -
  5.4743 -#define VK_KHR_external_fence_fd 1
  5.4744 -#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
  5.4745 -#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
  5.4746 -
  5.4747 -typedef struct VkImportFenceFdInfoKHR {
  5.4748 -    VkStructureType                         sType;
  5.4749 -    const void*                             pNext;
  5.4750 -    VkFence                                 fence;
  5.4751 -    VkFenceImportFlagsKHR                   flags;
  5.4752 -    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  5.4753 -    int                                     fd;
  5.4754 -} VkImportFenceFdInfoKHR;
  5.4755 -
  5.4756 -typedef struct VkFenceGetFdInfoKHR {
  5.4757 -    VkStructureType                         sType;
  5.4758 -    const void*                             pNext;
  5.4759 -    VkFence                                 fence;
  5.4760 -    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
  5.4761 -} VkFenceGetFdInfoKHR;
  5.4762 -
  5.4763 -
  5.4764 -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
  5.4765 -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
  5.4766 -
  5.4767 -#ifndef VK_NO_PROTOTYPES
  5.4768 -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
  5.4769 -    VkDevice                                    device,
  5.4770 -    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
  5.4771 -
  5.4772 -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
  5.4773 -    VkDevice                                    device,
  5.4774 -    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
  5.4775 -    int*                                        pFd);
  5.4776 -#endif
  5.4777 -
  5.4778 -#define VK_KHR_get_surface_capabilities2 1
  5.4779 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
  5.4780 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
  5.4781 -
  5.4782 -typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
  5.4783 -    VkStructureType    sType;
  5.4784 -    const void*        pNext;
  5.4785 -    VkSurfaceKHR       surface;
  5.4786 -} VkPhysicalDeviceSurfaceInfo2KHR;
  5.4787 -
  5.4788 -typedef struct VkSurfaceCapabilities2KHR {
  5.4789 -    VkStructureType             sType;
  5.4790 -    void*                       pNext;
  5.4791 -    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
  5.4792 -} VkSurfaceCapabilities2KHR;
  5.4793 -
  5.4794 -typedef struct VkSurfaceFormat2KHR {
  5.4795 -    VkStructureType       sType;
  5.4796 -    void*                 pNext;
  5.4797 -    VkSurfaceFormatKHR    surfaceFormat;
  5.4798 -} VkSurfaceFormat2KHR;
  5.4799 -
  5.4800 -
  5.4801 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
  5.4802 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
  5.4803 -
  5.4804 -#ifndef VK_NO_PROTOTYPES
  5.4805 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
  5.4806 -    VkPhysicalDevice                            physicalDevice,
  5.4807 -    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
  5.4808 -    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
  5.4809 -
  5.4810 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
  5.4811 -    VkPhysicalDevice                            physicalDevice,
  5.4812 -    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
  5.4813 -    uint32_t*                                   pSurfaceFormatCount,
  5.4814 -    VkSurfaceFormat2KHR*                        pSurfaceFormats);
  5.4815 -#endif
  5.4816 -
  5.4817 -#define VK_KHR_variable_pointers 1
  5.4818 -#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
  5.4819 -#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
  5.4820 -
  5.4821 -typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR {
  5.4822 -    VkStructureType    sType;
  5.4823 -    void*              pNext;
  5.4824 -    VkBool32           variablePointersStorageBuffer;
  5.4825 -    VkBool32           variablePointers;
  5.4826 -} VkPhysicalDeviceVariablePointerFeaturesKHR;
  5.4827 -
  5.4828 -
  5.4829 -
  5.4830 -#define VK_KHR_dedicated_allocation 1
  5.4831 -#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
  5.4832 -#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
  5.4833 -
  5.4834 -typedef struct VkMemoryDedicatedRequirementsKHR {
  5.4835 -    VkStructureType    sType;
  5.4836 -    void*              pNext;
  5.4837 -    VkBool32           prefersDedicatedAllocation;
  5.4838 -    VkBool32           requiresDedicatedAllocation;
  5.4839 -} VkMemoryDedicatedRequirementsKHR;
  5.4840 -
  5.4841 -typedef struct VkMemoryDedicatedAllocateInfoKHR {
  5.4842 -    VkStructureType    sType;
  5.4843 -    const void*        pNext;
  5.4844 -    VkImage            image;
  5.4845 -    VkBuffer           buffer;
  5.4846 -} VkMemoryDedicatedAllocateInfoKHR;
  5.4847 -
  5.4848 -
  5.4849 -
  5.4850 -#define VK_KHR_storage_buffer_storage_class 1
  5.4851 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
  5.4852 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
  5.4853 -
  5.4854 -
  5.4855 -#define VK_KHR_relaxed_block_layout 1
  5.4856 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
  5.4857 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
  5.4858 -
  5.4859 -
  5.4860 -#define VK_KHR_get_memory_requirements2 1
  5.4861 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
  5.4862 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
  5.4863 -
  5.4864 -typedef struct VkBufferMemoryRequirementsInfo2KHR {
  5.4865 -    VkStructureType    sType;
  5.4866 -    const void*        pNext;
  5.4867 -    VkBuffer           buffer;
  5.4868 -} VkBufferMemoryRequirementsInfo2KHR;
  5.4869 -
  5.4870 -typedef struct VkImageMemoryRequirementsInfo2KHR {
  5.4871 -    VkStructureType    sType;
  5.4872 -    const void*        pNext;
  5.4873 -    VkImage            image;
  5.4874 -} VkImageMemoryRequirementsInfo2KHR;
  5.4875 -
  5.4876 -typedef struct VkImageSparseMemoryRequirementsInfo2KHR {
  5.4877 -    VkStructureType    sType;
  5.4878 -    const void*        pNext;
  5.4879 -    VkImage            image;
  5.4880 -} VkImageSparseMemoryRequirementsInfo2KHR;
  5.4881 -
  5.4882 -typedef struct VkMemoryRequirements2KHR {
  5.4883 -    VkStructureType         sType;
  5.4884 -    void*                   pNext;
  5.4885 -    VkMemoryRequirements    memoryRequirements;
  5.4886 -} VkMemoryRequirements2KHR;
  5.4887 -
  5.4888 -typedef struct VkSparseImageMemoryRequirements2KHR {
  5.4889 -    VkStructureType                    sType;
  5.4890 -    void*                              pNext;
  5.4891 -    VkSparseImageMemoryRequirements    memoryRequirements;
  5.4892 -} VkSparseImageMemoryRequirements2KHR;
  5.4893 -
  5.4894 -
  5.4895 -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
  5.4896 -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
  5.4897 -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
  5.4898 -
  5.4899 -#ifndef VK_NO_PROTOTYPES
  5.4900 -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
  5.4901 -    VkDevice                                    device,
  5.4902 -    const VkImageMemoryRequirementsInfo2KHR*    pInfo,
  5.4903 -    VkMemoryRequirements2KHR*                   pMemoryRequirements);
  5.4904 -
  5.4905 -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
  5.4906 -    VkDevice                                    device,
  5.4907 -    const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
  5.4908 -    VkMemoryRequirements2KHR*                   pMemoryRequirements);
  5.4909 -
  5.4910 -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
  5.4911 -    VkDevice                                    device,
  5.4912 -    const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
  5.4913 -    uint32_t*                                   pSparseMemoryRequirementCount,
  5.4914 -    VkSparseImageMemoryRequirements2KHR*        pSparseMemoryRequirements);
  5.4915 -#endif
  5.4916 -
  5.4917 -#define VK_EXT_debug_report 1
  5.4918 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
  5.4919 -
  5.4920 -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  8
  5.4921 -#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
  5.4922 -#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
  5.4923 -#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT
  5.4924 -
  5.4925 -
  5.4926 -typedef enum VkDebugReportObjectTypeEXT {
  5.4927 -    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
  5.4928 -    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
  5.4929 -    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
  5.4930 -    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
  5.4931 -    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
  5.4932 -    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
  5.4933 -    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
  5.4934 -    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
  5.4935 -    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
  5.4936 -    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
  5.4937 -    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
  5.4938 -    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
  5.4939 -    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
  5.4940 -    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
  5.4941 -    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
  5.4942 -    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
  5.4943 -    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
  5.4944 -    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
  5.4945 -    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
  5.4946 -    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
  5.4947 -    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
  5.4948 -    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
  5.4949 -    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
  5.4950 -    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
  5.4951 -    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
  5.4952 -    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
  5.4953 -    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
  5.4954 -    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
  5.4955 -    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
  5.4956 -    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
  5.4957 -    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
  5.4958 -    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
  5.4959 -    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
  5.4960 -    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
  5.4961 -    VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
  5.4962 -    VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
  5.4963 -    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),
  5.4964 -    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
  5.4965 -} VkDebugReportObjectTypeEXT;
  5.4966 -
  5.4967 -
  5.4968 -typedef enum VkDebugReportFlagBitsEXT {
  5.4969 -    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
  5.4970 -    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
  5.4971 -    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
  5.4972 -    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
  5.4973 -    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
  5.4974 -    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
  5.4975 -} VkDebugReportFlagBitsEXT;
  5.4976 -typedef VkFlags VkDebugReportFlagsEXT;
  5.4977 -
  5.4978 -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
  5.4979 -    VkDebugReportFlagsEXT                       flags,
  5.4980 -    VkDebugReportObjectTypeEXT                  objectType,
  5.4981 -    uint64_t                                    object,
  5.4982 -    size_t                                      location,
  5.4983 -    int32_t                                     messageCode,
  5.4984 -    const char*                                 pLayerPrefix,
  5.4985 -    const char*                                 pMessage,
  5.4986 -    void*                                       pUserData);
  5.4987 -
  5.4988 -typedef struct VkDebugReportCallbackCreateInfoEXT {
  5.4989 -    VkStructureType                 sType;
  5.4990 -    const void*                     pNext;
  5.4991 -    VkDebugReportFlagsEXT           flags;
  5.4992 -    PFN_vkDebugReportCallbackEXT    pfnCallback;
  5.4993 -    void*                           pUserData;
  5.4994 -} VkDebugReportCallbackCreateInfoEXT;
  5.4995 -
  5.4996 -
  5.4997 -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
  5.4998 -typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
  5.4999 -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);
  5.5000 -
  5.5001 -#ifndef VK_NO_PROTOTYPES
  5.5002 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
  5.5003 -    VkInstance                                  instance,
  5.5004 -    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
  5.5005 -    const VkAllocationCallbacks*                pAllocator,
  5.5006 -    VkDebugReportCallbackEXT*                   pCallback);
  5.5007 -
  5.5008 -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
  5.5009 -    VkInstance                                  instance,
  5.5010 -    VkDebugReportCallbackEXT                    callback,
  5.5011 -    const VkAllocationCallbacks*                pAllocator);
  5.5012 -
  5.5013 -VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
  5.5014 -    VkInstance                                  instance,
  5.5015 -    VkDebugReportFlagsEXT                       flags,
  5.5016 -    VkDebugReportObjectTypeEXT                  objectType,
  5.5017 -    uint64_t                                    object,
  5.5018 -    size_t                                      location,
  5.5019 -    int32_t                                     messageCode,
  5.5020 -    const char*                                 pLayerPrefix,
  5.5021 -    const char*                                 pMessage);
  5.5022 -#endif
  5.5023 -
  5.5024 -#define VK_NV_glsl_shader 1
  5.5025 -#define VK_NV_GLSL_SHADER_SPEC_VERSION    1
  5.5026 -#define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
  5.5027 -
  5.5028 -
  5.5029 -#define VK_EXT_depth_range_unrestricted 1
  5.5030 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
  5.5031 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
  5.5032 -
  5.5033 -
  5.5034 -#define VK_IMG_filter_cubic 1
  5.5035 -#define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
  5.5036 -#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
  5.5037 -
  5.5038 -
  5.5039 -#define VK_AMD_rasterization_order 1
  5.5040 -#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
  5.5041 -#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
  5.5042 -
  5.5043 -
  5.5044 -typedef enum VkRasterizationOrderAMD {
  5.5045 -    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
  5.5046 -    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
  5.5047 -    VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
  5.5048 -    VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
  5.5049 -    VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
  5.5050 -    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
  5.5051 -} VkRasterizationOrderAMD;
  5.5052 -
  5.5053 -typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
  5.5054 -    VkStructureType            sType;
  5.5055 -    const void*                pNext;
  5.5056 -    VkRasterizationOrderAMD    rasterizationOrder;
  5.5057 -} VkPipelineRasterizationStateRasterizationOrderAMD;
  5.5058 -
  5.5059 -
  5.5060 -
  5.5061 -#define VK_AMD_shader_trinary_minmax 1
  5.5062 -#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
  5.5063 -#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
  5.5064 -
  5.5065 -
  5.5066 -#define VK_AMD_shader_explicit_vertex_parameter 1
  5.5067 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
  5.5068 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
  5.5069 -
  5.5070 -
  5.5071 -#define VK_EXT_debug_marker 1
  5.5072 -#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
  5.5073 -#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
  5.5074 -
  5.5075 -typedef struct VkDebugMarkerObjectNameInfoEXT {
  5.5076 -    VkStructureType               sType;
  5.5077 -    const void*                   pNext;
  5.5078 -    VkDebugReportObjectTypeEXT    objectType;
  5.5079 -    uint64_t                      object;
  5.5080 -    const char*                   pObjectName;
  5.5081 -} VkDebugMarkerObjectNameInfoEXT;
  5.5082 -
  5.5083 -typedef struct VkDebugMarkerObjectTagInfoEXT {
  5.5084 -    VkStructureType               sType;
  5.5085 -    const void*                   pNext;
  5.5086 -    VkDebugReportObjectTypeEXT    objectType;
  5.5087 -    uint64_t                      object;
  5.5088 -    uint64_t                      tagName;
  5.5089 -    size_t                        tagSize;
  5.5090 -    const void*                   pTag;
  5.5091 -} VkDebugMarkerObjectTagInfoEXT;
  5.5092 -
  5.5093 -typedef struct VkDebugMarkerMarkerInfoEXT {
  5.5094 -    VkStructureType    sType;
  5.5095 -    const void*        pNext;
  5.5096 -    const char*        pMarkerName;
  5.5097 -    float              color[4];
  5.5098 -} VkDebugMarkerMarkerInfoEXT;
  5.5099 -
  5.5100 -
  5.5101 -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
  5.5102 -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
  5.5103 -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
  5.5104 -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
  5.5105 -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
  5.5106 -
  5.5107 -#ifndef VK_NO_PROTOTYPES
  5.5108 -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
  5.5109 -    VkDevice                                    device,
  5.5110 -    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
  5.5111 -
  5.5112 -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
  5.5113 -    VkDevice                                    device,
  5.5114 -    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
  5.5115 -
  5.5116 -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
  5.5117 -    VkCommandBuffer                             commandBuffer,
  5.5118 -    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
  5.5119 -
  5.5120 -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
  5.5121 -    VkCommandBuffer                             commandBuffer);
  5.5122 -
  5.5123 -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
  5.5124 -    VkCommandBuffer                             commandBuffer,
  5.5125 -    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
  5.5126 -#endif
  5.5127 -
  5.5128 -#define VK_AMD_gcn_shader 1
  5.5129 -#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
  5.5130 -#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
  5.5131 -
  5.5132 -
  5.5133 -#define VK_NV_dedicated_allocation 1
  5.5134 -#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
  5.5135 -#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
  5.5136 -
  5.5137 -typedef struct VkDedicatedAllocationImageCreateInfoNV {
  5.5138 -    VkStructureType    sType;
  5.5139 -    const void*        pNext;
  5.5140 -    VkBool32           dedicatedAllocation;
  5.5141 -} VkDedicatedAllocationImageCreateInfoNV;
  5.5142 -
  5.5143 -typedef struct VkDedicatedAllocationBufferCreateInfoNV {
  5.5144 -    VkStructureType    sType;
  5.5145 -    const void*        pNext;
  5.5146 -    VkBool32           dedicatedAllocation;
  5.5147 -} VkDedicatedAllocationBufferCreateInfoNV;
  5.5148 -
  5.5149 -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
  5.5150 -    VkStructureType    sType;
  5.5151 -    const void*        pNext;
  5.5152 -    VkImage            image;
  5.5153 -    VkBuffer           buffer;
  5.5154 -} VkDedicatedAllocationMemoryAllocateInfoNV;
  5.5155 -
  5.5156 -
  5.5157 -
  5.5158 -#define VK_AMD_draw_indirect_count 1
  5.5159 -#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
  5.5160 -#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
  5.5161 -
  5.5162 -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
  5.5163 -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
  5.5164 -
  5.5165 -#ifndef VK_NO_PROTOTYPES
  5.5166 -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
  5.5167 -    VkCommandBuffer                             commandBuffer,
  5.5168 -    VkBuffer                                    buffer,
  5.5169 -    VkDeviceSize                                offset,
  5.5170 -    VkBuffer                                    countBuffer,
  5.5171 -    VkDeviceSize                                countBufferOffset,
  5.5172 -    uint32_t                                    maxDrawCount,
  5.5173 -    uint32_t                                    stride);
  5.5174 -
  5.5175 -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
  5.5176 -    VkCommandBuffer                             commandBuffer,
  5.5177 -    VkBuffer                                    buffer,
  5.5178 -    VkDeviceSize                                offset,
  5.5179 -    VkBuffer                                    countBuffer,
  5.5180 -    VkDeviceSize                                countBufferOffset,
  5.5181 -    uint32_t                                    maxDrawCount,
  5.5182 -    uint32_t                                    stride);
  5.5183 -#endif
  5.5184 -
  5.5185 -#define VK_AMD_negative_viewport_height 1
  5.5186 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
  5.5187 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
  5.5188 -
  5.5189 -
  5.5190 -#define VK_AMD_gpu_shader_half_float 1
  5.5191 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
  5.5192 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
  5.5193 -
  5.5194 -
  5.5195 -#define VK_AMD_shader_ballot 1
  5.5196 -#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
  5.5197 -#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
  5.5198 -
  5.5199 -
  5.5200 -#define VK_AMD_texture_gather_bias_lod 1
  5.5201 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
  5.5202 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
  5.5203 -
  5.5204 -typedef struct VkTextureLODGatherFormatPropertiesAMD {
  5.5205 -    VkStructureType    sType;
  5.5206 -    void*              pNext;
  5.5207 -    VkBool32           supportsTextureGatherLODBiasAMD;
  5.5208 -} VkTextureLODGatherFormatPropertiesAMD;
  5.5209 -
  5.5210 -
  5.5211 -
  5.5212 -#define VK_KHX_multiview 1
  5.5213 -#define VK_KHX_MULTIVIEW_SPEC_VERSION     1
  5.5214 -#define VK_KHX_MULTIVIEW_EXTENSION_NAME   "VK_KHX_multiview"
  5.5215 -
  5.5216 -typedef struct VkRenderPassMultiviewCreateInfoKHX {
  5.5217 -    VkStructureType    sType;
  5.5218 -    const void*        pNext;
  5.5219 -    uint32_t           subpassCount;
  5.5220 -    const uint32_t*    pViewMasks;
  5.5221 -    uint32_t           dependencyCount;
  5.5222 -    const int32_t*     pViewOffsets;
  5.5223 -    uint32_t           correlationMaskCount;
  5.5224 -    const uint32_t*    pCorrelationMasks;
  5.5225 -} VkRenderPassMultiviewCreateInfoKHX;
  5.5226 -
  5.5227 -typedef struct VkPhysicalDeviceMultiviewFeaturesKHX {
  5.5228 -    VkStructureType    sType;
  5.5229 -    void*              pNext;
  5.5230 -    VkBool32           multiview;
  5.5231 -    VkBool32           multiviewGeometryShader;
  5.5232 -    VkBool32           multiviewTessellationShader;
  5.5233 -} VkPhysicalDeviceMultiviewFeaturesKHX;
  5.5234 -
  5.5235 -typedef struct VkPhysicalDeviceMultiviewPropertiesKHX {
  5.5236 -    VkStructureType    sType;
  5.5237 -    void*              pNext;
  5.5238 -    uint32_t           maxMultiviewViewCount;
  5.5239 -    uint32_t           maxMultiviewInstanceIndex;
  5.5240 -} VkPhysicalDeviceMultiviewPropertiesKHX;
  5.5241 -
  5.5242 -
  5.5243 -
  5.5244 -#define VK_IMG_format_pvrtc 1
  5.5245 -#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
  5.5246 -#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
  5.5247 -
  5.5248 -
  5.5249 -#define VK_NV_external_memory_capabilities 1
  5.5250 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
  5.5251 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
  5.5252 -
  5.5253 -
  5.5254 -typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
  5.5255 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
  5.5256 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
  5.5257 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
  5.5258 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
  5.5259 -    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
  5.5260 -} VkExternalMemoryHandleTypeFlagBitsNV;
  5.5261 -typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
  5.5262 -
  5.5263 -typedef enum VkExternalMemoryFeatureFlagBitsNV {
  5.5264 -    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
  5.5265 -    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
  5.5266 -    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
  5.5267 -    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
  5.5268 -} VkExternalMemoryFeatureFlagBitsNV;
  5.5269 -typedef VkFlags VkExternalMemoryFeatureFlagsNV;
  5.5270 -
  5.5271 -typedef struct VkExternalImageFormatPropertiesNV {
  5.5272 -    VkImageFormatProperties              imageFormatProperties;
  5.5273 -    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
  5.5274 -    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
  5.5275 -    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
  5.5276 -} VkExternalImageFormatPropertiesNV;
  5.5277 -
  5.5278 -
  5.5279 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
  5.5280 -
  5.5281 -#ifndef VK_NO_PROTOTYPES
  5.5282 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
  5.5283 -    VkPhysicalDevice                            physicalDevice,
  5.5284 -    VkFormat                                    format,
  5.5285 -    VkImageType                                 type,
  5.5286 -    VkImageTiling                               tiling,
  5.5287 -    VkImageUsageFlags                           usage,
  5.5288 -    VkImageCreateFlags                          flags,
  5.5289 -    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
  5.5290 -    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
  5.5291 -#endif
  5.5292 -
  5.5293 -#define VK_NV_external_memory 1
  5.5294 -#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
  5.5295 -#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
  5.5296 -
  5.5297 -typedef struct VkExternalMemoryImageCreateInfoNV {
  5.5298 -    VkStructureType                      sType;
  5.5299 -    const void*                          pNext;
  5.5300 -    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
  5.5301 -} VkExternalMemoryImageCreateInfoNV;
  5.5302 -
  5.5303 -typedef struct VkExportMemoryAllocateInfoNV {
  5.5304 -    VkStructureType                      sType;
  5.5305 -    const void*                          pNext;
  5.5306 -    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
  5.5307 -} VkExportMemoryAllocateInfoNV;
  5.5308 -
  5.5309 -
  5.5310 -
  5.5311 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.5312 -#define VK_NV_external_memory_win32 1
  5.5313 -#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
  5.5314 -#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
  5.5315 -
  5.5316 -typedef struct VkImportMemoryWin32HandleInfoNV {
  5.5317 -    VkStructureType                      sType;
  5.5318 -    const void*                          pNext;
  5.5319 -    VkExternalMemoryHandleTypeFlagsNV    handleType;
  5.5320 -    HANDLE                               handle;
  5.5321 -} VkImportMemoryWin32HandleInfoNV;
  5.5322 -
  5.5323 -typedef struct VkExportMemoryWin32HandleInfoNV {
  5.5324 -    VkStructureType               sType;
  5.5325 -    const void*                   pNext;
  5.5326 -    const SECURITY_ATTRIBUTES*    pAttributes;
  5.5327 -    DWORD                         dwAccess;
  5.5328 -} VkExportMemoryWin32HandleInfoNV;
  5.5329 -
  5.5330 -
  5.5331 -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
  5.5332 -
  5.5333 -#ifndef VK_NO_PROTOTYPES
  5.5334 -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
  5.5335 -    VkDevice                                    device,
  5.5336 -    VkDeviceMemory                              memory,
  5.5337 -    VkExternalMemoryHandleTypeFlagsNV           handleType,
  5.5338 -    HANDLE*                                     pHandle);
  5.5339 -#endif
  5.5340 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.5341 -
  5.5342 -#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.5343 -#define VK_NV_win32_keyed_mutex 1
  5.5344 -#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
  5.5345 -#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
  5.5346 -
  5.5347 -typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
  5.5348 -    VkStructureType          sType;
  5.5349 -    const void*              pNext;
  5.5350 -    uint32_t                 acquireCount;
  5.5351 -    const VkDeviceMemory*    pAcquireSyncs;
  5.5352 -    const uint64_t*          pAcquireKeys;
  5.5353 -    const uint32_t*          pAcquireTimeoutMilliseconds;
  5.5354 -    uint32_t                 releaseCount;
  5.5355 -    const VkDeviceMemory*    pReleaseSyncs;
  5.5356 -    const uint64_t*          pReleaseKeys;
  5.5357 -} VkWin32KeyedMutexAcquireReleaseInfoNV;
  5.5358 -
  5.5359 -
  5.5360 -#endif /* VK_USE_PLATFORM_WIN32_KHR */
  5.5361 -
  5.5362 -#define VK_KHX_device_group 1
  5.5363 -#define VK_MAX_DEVICE_GROUP_SIZE_KHX      32
  5.5364 -#define VK_KHX_DEVICE_GROUP_SPEC_VERSION  1
  5.5365 -#define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group"
  5.5366 -
  5.5367 -
  5.5368 -typedef enum VkPeerMemoryFeatureFlagBitsKHX {
  5.5369 -    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001,
  5.5370 -    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002,
  5.5371 -    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004,
  5.5372 -    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008,
  5.5373 -    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
  5.5374 -} VkPeerMemoryFeatureFlagBitsKHX;
  5.5375 -typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
  5.5376 -
  5.5377 -typedef enum VkMemoryAllocateFlagBitsKHX {
  5.5378 -    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001,
  5.5379 -    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
  5.5380 -} VkMemoryAllocateFlagBitsKHX;
  5.5381 -typedef VkFlags VkMemoryAllocateFlagsKHX;
  5.5382 -
  5.5383 -typedef enum VkDeviceGroupPresentModeFlagBitsKHX {
  5.5384 -    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001,
  5.5385 -    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002,
  5.5386 -    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004,
  5.5387 -    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008,
  5.5388 -    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
  5.5389 -} VkDeviceGroupPresentModeFlagBitsKHX;
  5.5390 -typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
  5.5391 -
  5.5392 -typedef struct VkMemoryAllocateFlagsInfoKHX {
  5.5393 -    VkStructureType             sType;
  5.5394 -    const void*                 pNext;
  5.5395 -    VkMemoryAllocateFlagsKHX    flags;
  5.5396 -    uint32_t                    deviceMask;
  5.5397 -} VkMemoryAllocateFlagsInfoKHX;
  5.5398 -
  5.5399 -typedef struct VkBindBufferMemoryInfoKHX {
  5.5400 -    VkStructureType    sType;
  5.5401 -    const void*        pNext;
  5.5402 -    VkBuffer           buffer;
  5.5403 -    VkDeviceMemory     memory;
  5.5404 -    VkDeviceSize       memoryOffset;
  5.5405 -    uint32_t           deviceIndexCount;
  5.5406 -    const uint32_t*    pDeviceIndices;
  5.5407 -} VkBindBufferMemoryInfoKHX;
  5.5408 -
  5.5409 -typedef struct VkBindImageMemoryInfoKHX {
  5.5410 -    VkStructureType    sType;
  5.5411 -    const void*        pNext;
  5.5412 -    VkImage            image;
  5.5413 -    VkDeviceMemory     memory;
  5.5414 -    VkDeviceSize       memoryOffset;
  5.5415 -    uint32_t           deviceIndexCount;
  5.5416 -    const uint32_t*    pDeviceIndices;
  5.5417 -    uint32_t           SFRRectCount;
  5.5418 -    const VkRect2D*    pSFRRects;
  5.5419 -} VkBindImageMemoryInfoKHX;
  5.5420 -
  5.5421 -typedef struct VkDeviceGroupRenderPassBeginInfoKHX {
  5.5422 -    VkStructureType    sType;
  5.5423 -    const void*        pNext;
  5.5424 -    uint32_t           deviceMask;
  5.5425 -    uint32_t           deviceRenderAreaCount;
  5.5426 -    const VkRect2D*    pDeviceRenderAreas;
  5.5427 -} VkDeviceGroupRenderPassBeginInfoKHX;
  5.5428 -
  5.5429 -typedef struct VkDeviceGroupCommandBufferBeginInfoKHX {
  5.5430 -    VkStructureType    sType;
  5.5431 -    const void*        pNext;
  5.5432 -    uint32_t           deviceMask;
  5.5433 -} VkDeviceGroupCommandBufferBeginInfoKHX;
  5.5434 -
  5.5435 -typedef struct VkDeviceGroupSubmitInfoKHX {
  5.5436 -    VkStructureType    sType;
  5.5437 -    const void*        pNext;
  5.5438 -    uint32_t           waitSemaphoreCount;
  5.5439 -    const uint32_t*    pWaitSemaphoreDeviceIndices;
  5.5440 -    uint32_t           commandBufferCount;
  5.5441 -    const uint32_t*    pCommandBufferDeviceMasks;
  5.5442 -    uint32_t           signalSemaphoreCount;
  5.5443 -    const uint32_t*    pSignalSemaphoreDeviceIndices;
  5.5444 -} VkDeviceGroupSubmitInfoKHX;
  5.5445 -
  5.5446 -typedef struct VkDeviceGroupBindSparseInfoKHX {
  5.5447 -    VkStructureType    sType;
  5.5448 -    const void*        pNext;
  5.5449 -    uint32_t           resourceDeviceIndex;
  5.5450 -    uint32_t           memoryDeviceIndex;
  5.5451 -} VkDeviceGroupBindSparseInfoKHX;
  5.5452 -
  5.5453 -typedef struct VkDeviceGroupPresentCapabilitiesKHX {
  5.5454 -    VkStructureType                     sType;
  5.5455 -    const void*                         pNext;
  5.5456 -    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
  5.5457 -    VkDeviceGroupPresentModeFlagsKHX    modes;
  5.5458 -} VkDeviceGroupPresentCapabilitiesKHX;
  5.5459 -
  5.5460 -typedef struct VkImageSwapchainCreateInfoKHX {
  5.5461 -    VkStructureType    sType;
  5.5462 -    const void*        pNext;
  5.5463 -    VkSwapchainKHR     swapchain;
  5.5464 -} VkImageSwapchainCreateInfoKHX;
  5.5465 -
  5.5466 -typedef struct VkBindImageMemorySwapchainInfoKHX {
  5.5467 -    VkStructureType    sType;
  5.5468 -    const void*        pNext;
  5.5469 -    VkSwapchainKHR     swapchain;
  5.5470 -    uint32_t           imageIndex;
  5.5471 -} VkBindImageMemorySwapchainInfoKHX;
  5.5472 -
  5.5473 -typedef struct VkAcquireNextImageInfoKHX {
  5.5474 -    VkStructureType    sType;
  5.5475 -    const void*        pNext;
  5.5476 -    VkSwapchainKHR     swapchain;
  5.5477 -    uint64_t           timeout;
  5.5478 -    VkSemaphore        semaphore;
  5.5479 -    VkFence            fence;
  5.5480 -    uint32_t           deviceMask;
  5.5481 -} VkAcquireNextImageInfoKHX;
  5.5482 -
  5.5483 -typedef struct VkDeviceGroupPresentInfoKHX {
  5.5484 -    VkStructureType                        sType;
  5.5485 -    const void*                            pNext;
  5.5486 -    uint32_t                               swapchainCount;
  5.5487 -    const uint32_t*                        pDeviceMasks;
  5.5488 -    VkDeviceGroupPresentModeFlagBitsKHX    mode;
  5.5489 -} VkDeviceGroupPresentInfoKHX;
  5.5490 -
  5.5491 -typedef struct VkDeviceGroupSwapchainCreateInfoKHX {
  5.5492 -    VkStructureType                     sType;
  5.5493 -    const void*                         pNext;
  5.5494 -    VkDeviceGroupPresentModeFlagsKHX    modes;
  5.5495 -} VkDeviceGroupSwapchainCreateInfoKHX;
  5.5496 -
  5.5497 -
  5.5498 -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures);
  5.5499 -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHX* pBindInfos);
  5.5500 -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHX* pBindInfos);
  5.5501 -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
  5.5502 -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities);
  5.5503 -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes);
  5.5504 -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex);
  5.5505 -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);
  5.5506 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
  5.5507 -
  5.5508 -#ifndef VK_NO_PROTOTYPES
  5.5509 -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX(
  5.5510 -    VkDevice                                    device,
  5.5511 -    uint32_t                                    heapIndex,
  5.5512 -    uint32_t                                    localDeviceIndex,
  5.5513 -    uint32_t                                    remoteDeviceIndex,
  5.5514 -    VkPeerMemoryFeatureFlagsKHX*                pPeerMemoryFeatures);
  5.5515 -
  5.5516 -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHX(
  5.5517 -    VkDevice                                    device,
  5.5518 -    uint32_t                                    bindInfoCount,
  5.5519 -    const VkBindBufferMemoryInfoKHX*            pBindInfos);
  5.5520 -
  5.5521 -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHX(
  5.5522 -    VkDevice                                    device,
  5.5523 -    uint32_t                                    bindInfoCount,
  5.5524 -    const VkBindImageMemoryInfoKHX*             pBindInfos);
  5.5525 -
  5.5526 -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX(
  5.5527 -    VkCommandBuffer                             commandBuffer,
  5.5528 -    uint32_t                                    deviceMask);
  5.5529 -
  5.5530 -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX(
  5.5531 -    VkDevice                                    device,
  5.5532 -    VkDeviceGroupPresentCapabilitiesKHX*        pDeviceGroupPresentCapabilities);
  5.5533 -
  5.5534 -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX(
  5.5535 -    VkDevice                                    device,
  5.5536 -    VkSurfaceKHR                                surface,
  5.5537 -    VkDeviceGroupPresentModeFlagsKHX*           pModes);
  5.5538 -
  5.5539 -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX(
  5.5540 -    VkDevice                                    device,
  5.5541 -    const VkAcquireNextImageInfoKHX*            pAcquireInfo,
  5.5542 -    uint32_t*                                   pImageIndex);
  5.5543 -
  5.5544 -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX(
  5.5545 -    VkCommandBuffer                             commandBuffer,
  5.5546 -    uint32_t                                    baseGroupX,
  5.5547 -    uint32_t                                    baseGroupY,
  5.5548 -    uint32_t                                    baseGroupZ,
  5.5549 -    uint32_t                                    groupCountX,
  5.5550 -    uint32_t                                    groupCountY,
  5.5551 -    uint32_t                                    groupCountZ);
  5.5552 -
  5.5553 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX(
  5.5554 -    VkPhysicalDevice                            physicalDevice,
  5.5555 -    VkSurfaceKHR                                surface,
  5.5556 -    uint32_t*                                   pRectCount,
  5.5557 -    VkRect2D*                                   pRects);
  5.5558 -#endif
  5.5559 -
  5.5560 -#define VK_EXT_validation_flags 1
  5.5561 -#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
  5.5562 -#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
  5.5563 -
  5.5564 -
  5.5565 -typedef enum VkValidationCheckEXT {
  5.5566 -    VK_VALIDATION_CHECK_ALL_EXT = 0,
  5.5567 -    VK_VALIDATION_CHECK_SHADERS_EXT = 1,
  5.5568 -    VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
  5.5569 -    VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT,
  5.5570 -    VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
  5.5571 -    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
  5.5572 -} VkValidationCheckEXT;
  5.5573 -
  5.5574 -typedef struct VkValidationFlagsEXT {
  5.5575 -    VkStructureType          sType;
  5.5576 -    const void*              pNext;
  5.5577 -    uint32_t                 disabledValidationCheckCount;
  5.5578 -    VkValidationCheckEXT*    pDisabledValidationChecks;
  5.5579 -} VkValidationFlagsEXT;
  5.5580 -
  5.5581 -
  5.5582 -
  5.5583 -#ifdef VK_USE_PLATFORM_VI_NN
  5.5584 -#define VK_NN_vi_surface 1
  5.5585 -#define VK_NN_VI_SURFACE_SPEC_VERSION     1
  5.5586 -#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
  5.5587 -
  5.5588 -typedef VkFlags VkViSurfaceCreateFlagsNN;
  5.5589 -
  5.5590 -typedef struct VkViSurfaceCreateInfoNN {
  5.5591 -    VkStructureType             sType;
  5.5592 -    const void*                 pNext;
  5.5593 -    VkViSurfaceCreateFlagsNN    flags;
  5.5594 -    void*                       window;
  5.5595 -} VkViSurfaceCreateInfoNN;
  5.5596 -
  5.5597 -
  5.5598 -typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.5599 -
  5.5600 -#ifndef VK_NO_PROTOTYPES
  5.5601 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
  5.5602 -    VkInstance                                  instance,
  5.5603 -    const VkViSurfaceCreateInfoNN*              pCreateInfo,
  5.5604 -    const VkAllocationCallbacks*                pAllocator,
  5.5605 -    VkSurfaceKHR*                               pSurface);
  5.5606 -#endif
  5.5607 -#endif /* VK_USE_PLATFORM_VI_NN */
  5.5608 -
  5.5609 -#define VK_EXT_shader_subgroup_ballot 1
  5.5610 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
  5.5611 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
  5.5612 -
  5.5613 -
  5.5614 -#define VK_EXT_shader_subgroup_vote 1
  5.5615 -#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
  5.5616 -#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
  5.5617 -
  5.5618 -
  5.5619 -#define VK_KHX_device_group_creation 1
  5.5620 -#define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1
  5.5621 -#define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation"
  5.5622 -
  5.5623 -typedef struct VkPhysicalDeviceGroupPropertiesKHX {
  5.5624 -    VkStructureType     sType;
  5.5625 -    void*               pNext;
  5.5626 -    uint32_t            physicalDeviceCount;
  5.5627 -    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
  5.5628 -    VkBool32            subsetAllocation;
  5.5629 -} VkPhysicalDeviceGroupPropertiesKHX;
  5.5630 -
  5.5631 -typedef struct VkDeviceGroupDeviceCreateInfoKHX {
  5.5632 -    VkStructureType            sType;
  5.5633 -    const void*                pNext;
  5.5634 -    uint32_t                   physicalDeviceCount;
  5.5635 -    const VkPhysicalDevice*    pPhysicalDevices;
  5.5636 -} VkDeviceGroupDeviceCreateInfoKHX;
  5.5637 -
  5.5638 -
  5.5639 -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties);
  5.5640 -
  5.5641 -#ifndef VK_NO_PROTOTYPES
  5.5642 -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX(
  5.5643 -    VkInstance                                  instance,
  5.5644 -    uint32_t*                                   pPhysicalDeviceGroupCount,
  5.5645 -    VkPhysicalDeviceGroupPropertiesKHX*         pPhysicalDeviceGroupProperties);
  5.5646 -#endif
  5.5647 -
  5.5648 -#define VK_NVX_device_generated_commands 1
  5.5649 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
  5.5650 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
  5.5651 -
  5.5652 -#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
  5.5653 -#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
  5.5654 -
  5.5655 -
  5.5656 -typedef enum VkIndirectCommandsTokenTypeNVX {
  5.5657 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
  5.5658 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
  5.5659 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
  5.5660 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
  5.5661 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
  5.5662 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
  5.5663 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
  5.5664 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
  5.5665 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
  5.5666 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX,
  5.5667 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1),
  5.5668 -    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
  5.5669 -} VkIndirectCommandsTokenTypeNVX;
  5.5670 -
  5.5671 -typedef enum VkObjectEntryTypeNVX {
  5.5672 -    VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
  5.5673 -    VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
  5.5674 -    VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
  5.5675 -    VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
  5.5676 -    VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
  5.5677 -    VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
  5.5678 -    VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX,
  5.5679 -    VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1),
  5.5680 -    VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
  5.5681 -} VkObjectEntryTypeNVX;
  5.5682 -
  5.5683 -
  5.5684 -typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
  5.5685 -    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
  5.5686 -    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
  5.5687 -    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
  5.5688 -    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
  5.5689 -    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
  5.5690 -} VkIndirectCommandsLayoutUsageFlagBitsNVX;
  5.5691 -typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
  5.5692 -
  5.5693 -typedef enum VkObjectEntryUsageFlagBitsNVX {
  5.5694 -    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
  5.5695 -    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
  5.5696 -    VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
  5.5697 -} VkObjectEntryUsageFlagBitsNVX;
  5.5698 -typedef VkFlags VkObjectEntryUsageFlagsNVX;
  5.5699 -
  5.5700 -typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
  5.5701 -    VkStructureType    sType;
  5.5702 -    const void*        pNext;
  5.5703 -    VkBool32           computeBindingPointSupport;
  5.5704 -} VkDeviceGeneratedCommandsFeaturesNVX;
  5.5705 -
  5.5706 -typedef struct VkDeviceGeneratedCommandsLimitsNVX {
  5.5707 -    VkStructureType    sType;
  5.5708 -    const void*        pNext;
  5.5709 -    uint32_t           maxIndirectCommandsLayoutTokenCount;
  5.5710 -    uint32_t           maxObjectEntryCounts;
  5.5711 -    uint32_t           minSequenceCountBufferOffsetAlignment;
  5.5712 -    uint32_t           minSequenceIndexBufferOffsetAlignment;
  5.5713 -    uint32_t           minCommandsTokenBufferOffsetAlignment;
  5.5714 -} VkDeviceGeneratedCommandsLimitsNVX;
  5.5715 -
  5.5716 -typedef struct VkIndirectCommandsTokenNVX {
  5.5717 -    VkIndirectCommandsTokenTypeNVX    tokenType;
  5.5718 -    VkBuffer                          buffer;
  5.5719 -    VkDeviceSize                      offset;
  5.5720 -} VkIndirectCommandsTokenNVX;
  5.5721 -
  5.5722 -typedef struct VkIndirectCommandsLayoutTokenNVX {
  5.5723 -    VkIndirectCommandsTokenTypeNVX    tokenType;
  5.5724 -    uint32_t                          bindingUnit;
  5.5725 -    uint32_t                          dynamicCount;
  5.5726 -    uint32_t                          divisor;
  5.5727 -} VkIndirectCommandsLayoutTokenNVX;
  5.5728 -
  5.5729 -typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
  5.5730 -    VkStructureType                            sType;
  5.5731 -    const void*                                pNext;
  5.5732 -    VkPipelineBindPoint                        pipelineBindPoint;
  5.5733 -    VkIndirectCommandsLayoutUsageFlagsNVX      flags;
  5.5734 -    uint32_t                                   tokenCount;
  5.5735 -    const VkIndirectCommandsLayoutTokenNVX*    pTokens;
  5.5736 -} VkIndirectCommandsLayoutCreateInfoNVX;
  5.5737 -
  5.5738 -typedef struct VkCmdProcessCommandsInfoNVX {
  5.5739 -    VkStructureType                      sType;
  5.5740 -    const void*                          pNext;
  5.5741 -    VkObjectTableNVX                     objectTable;
  5.5742 -    VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
  5.5743 -    uint32_t                             indirectCommandsTokenCount;
  5.5744 -    const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
  5.5745 -    uint32_t                             maxSequencesCount;
  5.5746 -    VkCommandBuffer                      targetCommandBuffer;
  5.5747 -    VkBuffer                             sequencesCountBuffer;
  5.5748 -    VkDeviceSize                         sequencesCountOffset;
  5.5749 -    VkBuffer                             sequencesIndexBuffer;
  5.5750 -    VkDeviceSize                         sequencesIndexOffset;
  5.5751 -} VkCmdProcessCommandsInfoNVX;
  5.5752 -
  5.5753 -typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
  5.5754 -    VkStructureType                sType;
  5.5755 -    const void*                    pNext;
  5.5756 -    VkObjectTableNVX               objectTable;
  5.5757 -    VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
  5.5758 -    uint32_t                       maxSequencesCount;
  5.5759 -} VkCmdReserveSpaceForCommandsInfoNVX;
  5.5760 -
  5.5761 -typedef struct VkObjectTableCreateInfoNVX {
  5.5762 -    VkStructureType                      sType;
  5.5763 -    const void*                          pNext;
  5.5764 -    uint32_t                             objectCount;
  5.5765 -    const VkObjectEntryTypeNVX*          pObjectEntryTypes;
  5.5766 -    const uint32_t*                      pObjectEntryCounts;
  5.5767 -    const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
  5.5768 -    uint32_t                             maxUniformBuffersPerDescriptor;
  5.5769 -    uint32_t                             maxStorageBuffersPerDescriptor;
  5.5770 -    uint32_t                             maxStorageImagesPerDescriptor;
  5.5771 -    uint32_t                             maxSampledImagesPerDescriptor;
  5.5772 -    uint32_t                             maxPipelineLayouts;
  5.5773 -} VkObjectTableCreateInfoNVX;
  5.5774 -
  5.5775 -typedef struct VkObjectTableEntryNVX {
  5.5776 -    VkObjectEntryTypeNVX          type;
  5.5777 -    VkObjectEntryUsageFlagsNVX    flags;
  5.5778 -} VkObjectTableEntryNVX;
  5.5779 -
  5.5780 -typedef struct VkObjectTablePipelineEntryNVX {
  5.5781 -    VkObjectEntryTypeNVX          type;
  5.5782 -    VkObjectEntryUsageFlagsNVX    flags;
  5.5783 -    VkPipeline                    pipeline;
  5.5784 -} VkObjectTablePipelineEntryNVX;
  5.5785 -
  5.5786 -typedef struct VkObjectTableDescriptorSetEntryNVX {
  5.5787 -    VkObjectEntryTypeNVX          type;
  5.5788 -    VkObjectEntryUsageFlagsNVX    flags;
  5.5789 -    VkPipelineLayout              pipelineLayout;
  5.5790 -    VkDescriptorSet               descriptorSet;
  5.5791 -} VkObjectTableDescriptorSetEntryNVX;
  5.5792 -
  5.5793 -typedef struct VkObjectTableVertexBufferEntryNVX {
  5.5794 -    VkObjectEntryTypeNVX          type;
  5.5795 -    VkObjectEntryUsageFlagsNVX    flags;
  5.5796 -    VkBuffer                      buffer;
  5.5797 -} VkObjectTableVertexBufferEntryNVX;
  5.5798 -
  5.5799 -typedef struct VkObjectTableIndexBufferEntryNVX {
  5.5800 -    VkObjectEntryTypeNVX          type;
  5.5801 -    VkObjectEntryUsageFlagsNVX    flags;
  5.5802 -    VkBuffer                      buffer;
  5.5803 -    VkIndexType                   indexType;
  5.5804 -} VkObjectTableIndexBufferEntryNVX;
  5.5805 -
  5.5806 -typedef struct VkObjectTablePushConstantEntryNVX {
  5.5807 -    VkObjectEntryTypeNVX          type;
  5.5808 -    VkObjectEntryUsageFlagsNVX    flags;
  5.5809 -    VkPipelineLayout              pipelineLayout;
  5.5810 -    VkShaderStageFlags            stageFlags;
  5.5811 -} VkObjectTablePushConstantEntryNVX;
  5.5812 -
  5.5813 -
  5.5814 -typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
  5.5815 -typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
  5.5816 -typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
  5.5817 -typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
  5.5818 -typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
  5.5819 -typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
  5.5820 -typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
  5.5821 -typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
  5.5822 -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
  5.5823 -
  5.5824 -#ifndef VK_NO_PROTOTYPES
  5.5825 -VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
  5.5826 -    VkCommandBuffer                             commandBuffer,
  5.5827 -    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
  5.5828 -
  5.5829 -VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
  5.5830 -    VkCommandBuffer                             commandBuffer,
  5.5831 -    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
  5.5832 -
  5.5833 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
  5.5834 -    VkDevice                                    device,
  5.5835 -    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
  5.5836 -    const VkAllocationCallbacks*                pAllocator,
  5.5837 -    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
  5.5838 -
  5.5839 -VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
  5.5840 -    VkDevice                                    device,
  5.5841 -    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
  5.5842 -    const VkAllocationCallbacks*                pAllocator);
  5.5843 -
  5.5844 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
  5.5845 -    VkDevice                                    device,
  5.5846 -    const VkObjectTableCreateInfoNVX*           pCreateInfo,
  5.5847 -    const VkAllocationCallbacks*                pAllocator,
  5.5848 -    VkObjectTableNVX*                           pObjectTable);
  5.5849 -
  5.5850 -VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
  5.5851 -    VkDevice                                    device,
  5.5852 -    VkObjectTableNVX                            objectTable,
  5.5853 -    const VkAllocationCallbacks*                pAllocator);
  5.5854 -
  5.5855 -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
  5.5856 -    VkDevice                                    device,
  5.5857 -    VkObjectTableNVX                            objectTable,
  5.5858 -    uint32_t                                    objectCount,
  5.5859 -    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
  5.5860 -    const uint32_t*                             pObjectIndices);
  5.5861 -
  5.5862 -VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
  5.5863 -    VkDevice                                    device,
  5.5864 -    VkObjectTableNVX                            objectTable,
  5.5865 -    uint32_t                                    objectCount,
  5.5866 -    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
  5.5867 -    const uint32_t*                             pObjectIndices);
  5.5868 -
  5.5869 -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
  5.5870 -    VkPhysicalDevice                            physicalDevice,
  5.5871 -    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
  5.5872 -    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
  5.5873 -#endif
  5.5874 -
  5.5875 -#define VK_NV_clip_space_w_scaling 1
  5.5876 -#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
  5.5877 -#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
  5.5878 -
  5.5879 -typedef struct VkViewportWScalingNV {
  5.5880 -    float    xcoeff;
  5.5881 -    float    ycoeff;
  5.5882 -} VkViewportWScalingNV;
  5.5883 -
  5.5884 -typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
  5.5885 -    VkStructureType                sType;
  5.5886 -    const void*                    pNext;
  5.5887 -    VkBool32                       viewportWScalingEnable;
  5.5888 -    uint32_t                       viewportCount;
  5.5889 -    const VkViewportWScalingNV*    pViewportWScalings;
  5.5890 -} VkPipelineViewportWScalingStateCreateInfoNV;
  5.5891 -
  5.5892 -
  5.5893 -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
  5.5894 -
  5.5895 -#ifndef VK_NO_PROTOTYPES
  5.5896 -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
  5.5897 -    VkCommandBuffer                             commandBuffer,
  5.5898 -    uint32_t                                    firstViewport,
  5.5899 -    uint32_t                                    viewportCount,
  5.5900 -    const VkViewportWScalingNV*                 pViewportWScalings);
  5.5901 -#endif
  5.5902 -
  5.5903 -#define VK_EXT_direct_mode_display 1
  5.5904 -#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
  5.5905 -#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
  5.5906 -
  5.5907 -typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
  5.5908 -
  5.5909 -#ifndef VK_NO_PROTOTYPES
  5.5910 -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
  5.5911 -    VkPhysicalDevice                            physicalDevice,
  5.5912 -    VkDisplayKHR                                display);
  5.5913 -#endif
  5.5914 -
  5.5915 -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
  5.5916 -#define VK_EXT_acquire_xlib_display 1
  5.5917 -#include <X11/extensions/Xrandr.h>
  5.5918 -
  5.5919 -#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
  5.5920 -#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
  5.5921 -
  5.5922 -typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
  5.5923 -typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
  5.5924 -
  5.5925 -#ifndef VK_NO_PROTOTYPES
  5.5926 -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
  5.5927 -    VkPhysicalDevice                            physicalDevice,
  5.5928 -    Display*                                    dpy,
  5.5929 -    VkDisplayKHR                                display);
  5.5930 -
  5.5931 -VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
  5.5932 -    VkPhysicalDevice                            physicalDevice,
  5.5933 -    Display*                                    dpy,
  5.5934 -    RROutput                                    rrOutput,
  5.5935 -    VkDisplayKHR*                               pDisplay);
  5.5936 -#endif
  5.5937 -#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
  5.5938 -
  5.5939 -#define VK_EXT_display_surface_counter 1
  5.5940 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
  5.5941 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
  5.5942 -#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
  5.5943 -
  5.5944 -
  5.5945 -typedef enum VkSurfaceCounterFlagBitsEXT {
  5.5946 -    VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
  5.5947 -    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
  5.5948 -} VkSurfaceCounterFlagBitsEXT;
  5.5949 -typedef VkFlags VkSurfaceCounterFlagsEXT;
  5.5950 -
  5.5951 -typedef struct VkSurfaceCapabilities2EXT {
  5.5952 -    VkStructureType                  sType;
  5.5953 -    void*                            pNext;
  5.5954 -    uint32_t                         minImageCount;
  5.5955 -    uint32_t                         maxImageCount;
  5.5956 -    VkExtent2D                       currentExtent;
  5.5957 -    VkExtent2D                       minImageExtent;
  5.5958 -    VkExtent2D                       maxImageExtent;
  5.5959 -    uint32_t                         maxImageArrayLayers;
  5.5960 -    VkSurfaceTransformFlagsKHR       supportedTransforms;
  5.5961 -    VkSurfaceTransformFlagBitsKHR    currentTransform;
  5.5962 -    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
  5.5963 -    VkImageUsageFlags                supportedUsageFlags;
  5.5964 -    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
  5.5965 -} VkSurfaceCapabilities2EXT;
  5.5966 -
  5.5967 -
  5.5968 -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
  5.5969 -
  5.5970 -#ifndef VK_NO_PROTOTYPES
  5.5971 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
  5.5972 -    VkPhysicalDevice                            physicalDevice,
  5.5973 -    VkSurfaceKHR                                surface,
  5.5974 -    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
  5.5975 -#endif
  5.5976 -
  5.5977 -#define VK_EXT_display_control 1
  5.5978 -#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
  5.5979 -#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
  5.5980 -
  5.5981 -
  5.5982 -typedef enum VkDisplayPowerStateEXT {
  5.5983 -    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
  5.5984 -    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
  5.5985 -    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
  5.5986 -    VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
  5.5987 -    VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
  5.5988 -    VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
  5.5989 -    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
  5.5990 -} VkDisplayPowerStateEXT;
  5.5991 -
  5.5992 -typedef enum VkDeviceEventTypeEXT {
  5.5993 -    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
  5.5994 -    VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
  5.5995 -    VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
  5.5996 -    VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
  5.5997 -    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
  5.5998 -} VkDeviceEventTypeEXT;
  5.5999 -
  5.6000 -typedef enum VkDisplayEventTypeEXT {
  5.6001 -    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
  5.6002 -    VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
  5.6003 -    VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
  5.6004 -    VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
  5.6005 -    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
  5.6006 -} VkDisplayEventTypeEXT;
  5.6007 -
  5.6008 -typedef struct VkDisplayPowerInfoEXT {
  5.6009 -    VkStructureType           sType;
  5.6010 -    const void*               pNext;
  5.6011 -    VkDisplayPowerStateEXT    powerState;
  5.6012 -} VkDisplayPowerInfoEXT;
  5.6013 -
  5.6014 -typedef struct VkDeviceEventInfoEXT {
  5.6015 -    VkStructureType         sType;
  5.6016 -    const void*             pNext;
  5.6017 -    VkDeviceEventTypeEXT    deviceEvent;
  5.6018 -} VkDeviceEventInfoEXT;
  5.6019 -
  5.6020 -typedef struct VkDisplayEventInfoEXT {
  5.6021 -    VkStructureType          sType;
  5.6022 -    const void*              pNext;
  5.6023 -    VkDisplayEventTypeEXT    displayEvent;
  5.6024 -} VkDisplayEventInfoEXT;
  5.6025 -
  5.6026 -typedef struct VkSwapchainCounterCreateInfoEXT {
  5.6027 -    VkStructureType             sType;
  5.6028 -    const void*                 pNext;
  5.6029 -    VkSurfaceCounterFlagsEXT    surfaceCounters;
  5.6030 -} VkSwapchainCounterCreateInfoEXT;
  5.6031 -
  5.6032 -
  5.6033 -typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
  5.6034 -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  5.6035 -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  5.6036 -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
  5.6037 -
  5.6038 -#ifndef VK_NO_PROTOTYPES
  5.6039 -VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
  5.6040 -    VkDevice                                    device,
  5.6041 -    VkDisplayKHR                                display,
  5.6042 -    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
  5.6043 -
  5.6044 -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
  5.6045 -    VkDevice                                    device,
  5.6046 -    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
  5.6047 -    const VkAllocationCallbacks*                pAllocator,
  5.6048 -    VkFence*                                    pFence);
  5.6049 -
  5.6050 -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
  5.6051 -    VkDevice                                    device,
  5.6052 -    VkDisplayKHR                                display,
  5.6053 -    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
  5.6054 -    const VkAllocationCallbacks*                pAllocator,
  5.6055 -    VkFence*                                    pFence);
  5.6056 -
  5.6057 -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
  5.6058 -    VkDevice                                    device,
  5.6059 -    VkSwapchainKHR                              swapchain,
  5.6060 -    VkSurfaceCounterFlagBitsEXT                 counter,
  5.6061 -    uint64_t*                                   pCounterValue);
  5.6062 -#endif
  5.6063 -
  5.6064 -#define VK_GOOGLE_display_timing 1
  5.6065 -#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
  5.6066 -#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
  5.6067 -
  5.6068 -typedef struct VkRefreshCycleDurationGOOGLE {
  5.6069 -    uint64_t    refreshDuration;
  5.6070 -} VkRefreshCycleDurationGOOGLE;
  5.6071 -
  5.6072 -typedef struct VkPastPresentationTimingGOOGLE {
  5.6073 -    uint32_t    presentID;
  5.6074 -    uint64_t    desiredPresentTime;
  5.6075 -    uint64_t    actualPresentTime;
  5.6076 -    uint64_t    earliestPresentTime;
  5.6077 -    uint64_t    presentMargin;
  5.6078 -} VkPastPresentationTimingGOOGLE;
  5.6079 -
  5.6080 -typedef struct VkPresentTimeGOOGLE {
  5.6081 -    uint32_t    presentID;
  5.6082 -    uint64_t    desiredPresentTime;
  5.6083 -} VkPresentTimeGOOGLE;
  5.6084 -
  5.6085 -typedef struct VkPresentTimesInfoGOOGLE {
  5.6086 -    VkStructureType               sType;
  5.6087 -    const void*                   pNext;
  5.6088 -    uint32_t                      swapchainCount;
  5.6089 -    const VkPresentTimeGOOGLE*    pTimes;
  5.6090 -} VkPresentTimesInfoGOOGLE;
  5.6091 -
  5.6092 -
  5.6093 -typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
  5.6094 -typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
  5.6095 -
  5.6096 -#ifndef VK_NO_PROTOTYPES
  5.6097 -VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
  5.6098 -    VkDevice                                    device,
  5.6099 -    VkSwapchainKHR                              swapchain,
  5.6100 -    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
  5.6101 -
  5.6102 -VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
  5.6103 -    VkDevice                                    device,
  5.6104 -    VkSwapchainKHR                              swapchain,
  5.6105 -    uint32_t*                                   pPresentationTimingCount,
  5.6106 -    VkPastPresentationTimingGOOGLE*             pPresentationTimings);
  5.6107 -#endif
  5.6108 -
  5.6109 -#define VK_NV_sample_mask_override_coverage 1
  5.6110 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
  5.6111 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
  5.6112 -
  5.6113 -
  5.6114 -#define VK_NV_geometry_shader_passthrough 1
  5.6115 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
  5.6116 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
  5.6117 -
  5.6118 -
  5.6119 -#define VK_NV_viewport_array2 1
  5.6120 -#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
  5.6121 -#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
  5.6122 -
  5.6123 -
  5.6124 -#define VK_NVX_multiview_per_view_attributes 1
  5.6125 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
  5.6126 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
  5.6127 -
  5.6128 -typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
  5.6129 -    VkStructureType    sType;
  5.6130 -    void*              pNext;
  5.6131 -    VkBool32           perViewPositionAllComponents;
  5.6132 -} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
  5.6133 -
  5.6134 -
  5.6135 -
  5.6136 -#define VK_NV_viewport_swizzle 1
  5.6137 -#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
  5.6138 -#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
  5.6139 -
  5.6140 -
  5.6141 -typedef enum VkViewportCoordinateSwizzleNV {
  5.6142 -    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
  5.6143 -    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
  5.6144 -    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
  5.6145 -    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
  5.6146 -    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
  5.6147 -    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
  5.6148 -    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
  5.6149 -    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
  5.6150 -    VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
  5.6151 -    VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
  5.6152 -    VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
  5.6153 -    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
  5.6154 -} VkViewportCoordinateSwizzleNV;
  5.6155 -
  5.6156 -typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
  5.6157 -
  5.6158 -typedef struct VkViewportSwizzleNV {
  5.6159 -    VkViewportCoordinateSwizzleNV    x;
  5.6160 -    VkViewportCoordinateSwizzleNV    y;
  5.6161 -    VkViewportCoordinateSwizzleNV    z;
  5.6162 -    VkViewportCoordinateSwizzleNV    w;
  5.6163 -} VkViewportSwizzleNV;
  5.6164 -
  5.6165 -typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
  5.6166 -    VkStructureType                                sType;
  5.6167 -    const void*                                    pNext;
  5.6168 -    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
  5.6169 -    uint32_t                                       viewportCount;
  5.6170 -    const VkViewportSwizzleNV*                     pViewportSwizzles;
  5.6171 -} VkPipelineViewportSwizzleStateCreateInfoNV;
  5.6172 -
  5.6173 -
  5.6174 -
  5.6175 -#define VK_EXT_discard_rectangles 1
  5.6176 -#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
  5.6177 -#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
  5.6178 -
  5.6179 -
  5.6180 -typedef enum VkDiscardRectangleModeEXT {
  5.6181 -    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
  5.6182 -    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
  5.6183 -    VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
  5.6184 -    VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
  5.6185 -    VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
  5.6186 -    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
  5.6187 -} VkDiscardRectangleModeEXT;
  5.6188 -
  5.6189 -typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
  5.6190 -
  5.6191 -typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
  5.6192 -    VkStructureType    sType;
  5.6193 -    void*              pNext;
  5.6194 -    uint32_t           maxDiscardRectangles;
  5.6195 -} VkPhysicalDeviceDiscardRectanglePropertiesEXT;
  5.6196 -
  5.6197 -typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
  5.6198 -    VkStructureType                                  sType;
  5.6199 -    const void*                                      pNext;
  5.6200 -    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
  5.6201 -    VkDiscardRectangleModeEXT                        discardRectangleMode;
  5.6202 -    uint32_t                                         discardRectangleCount;
  5.6203 -    const VkRect2D*                                  pDiscardRectangles;
  5.6204 -} VkPipelineDiscardRectangleStateCreateInfoEXT;
  5.6205 -
  5.6206 -
  5.6207 -typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
  5.6208 -
  5.6209 -#ifndef VK_NO_PROTOTYPES
  5.6210 -VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
  5.6211 -    VkCommandBuffer                             commandBuffer,
  5.6212 -    uint32_t                                    firstDiscardRectangle,
  5.6213 -    uint32_t                                    discardRectangleCount,
  5.6214 -    const VkRect2D*                             pDiscardRectangles);
  5.6215 -#endif
  5.6216 -
  5.6217 -#define VK_EXT_swapchain_colorspace 1
  5.6218 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3
  5.6219 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
  5.6220 -
  5.6221 -
  5.6222 -#define VK_EXT_hdr_metadata 1
  5.6223 -#define VK_EXT_HDR_METADATA_SPEC_VERSION  1
  5.6224 -#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
  5.6225 -
  5.6226 -typedef struct VkXYColorEXT {
  5.6227 -    float    x;
  5.6228 -    float    y;
  5.6229 -} VkXYColorEXT;
  5.6230 -
  5.6231 -typedef struct VkHdrMetadataEXT {
  5.6232 -    VkStructureType    sType;
  5.6233 -    const void*        pNext;
  5.6234 -    VkXYColorEXT       displayPrimaryRed;
  5.6235 -    VkXYColorEXT       displayPrimaryGreen;
  5.6236 -    VkXYColorEXT       displayPrimaryBlue;
  5.6237 -    VkXYColorEXT       whitePoint;
  5.6238 -    float              maxLuminance;
  5.6239 -    float              minLuminance;
  5.6240 -    float              maxContentLightLevel;
  5.6241 -    float              maxFrameAverageLightLevel;
  5.6242 -} VkHdrMetadataEXT;
  5.6243 -
  5.6244 -
  5.6245 -typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
  5.6246 -
  5.6247 -#ifndef VK_NO_PROTOTYPES
  5.6248 -VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
  5.6249 -    VkDevice                                    device,
  5.6250 -    uint32_t                                    swapchainCount,
  5.6251 -    const VkSwapchainKHR*                       pSwapchains,
  5.6252 -    const VkHdrMetadataEXT*                     pMetadata);
  5.6253 +#ifdef VK_USE_PLATFORM_FUCHSIA
  5.6254 +#include <zircon/types.h>
  5.6255 +#include "vulkan_fuchsia.h"
  5.6256  #endif
  5.6257  
  5.6258  #ifdef VK_USE_PLATFORM_IOS_MVK
  5.6259 -#define VK_MVK_ios_surface 1
  5.6260 -#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
  5.6261 -#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
  5.6262 +#include "vulkan_ios.h"
  5.6263 +#endif
  5.6264  
  5.6265 -typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
  5.6266 -
  5.6267 -typedef struct VkIOSSurfaceCreateInfoMVK {
  5.6268 -    VkStructureType               sType;
  5.6269 -    const void*                   pNext;
  5.6270 -    VkIOSSurfaceCreateFlagsMVK    flags;
  5.6271 -    const void*                   pView;
  5.6272 -} VkIOSSurfaceCreateInfoMVK;
  5.6273 -
  5.6274 -
  5.6275 -typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.6276 -
  5.6277 -#ifndef VK_NO_PROTOTYPES
  5.6278 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
  5.6279 -    VkInstance                                  instance,
  5.6280 -    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
  5.6281 -    const VkAllocationCallbacks*                pAllocator,
  5.6282 -    VkSurfaceKHR*                               pSurface);
  5.6283 -#endif
  5.6284 -#endif /* VK_USE_PLATFORM_IOS_MVK */
  5.6285  
  5.6286  #ifdef VK_USE_PLATFORM_MACOS_MVK
  5.6287 -#define VK_MVK_macos_surface 1
  5.6288 -#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
  5.6289 -#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
  5.6290 -
  5.6291 -typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
  5.6292 -
  5.6293 -typedef struct VkMacOSSurfaceCreateInfoMVK {
  5.6294 -    VkStructureType                 sType;
  5.6295 -    const void*                     pNext;
  5.6296 -    VkMacOSSurfaceCreateFlagsMVK    flags;
  5.6297 -    const void*                     pView;
  5.6298 -} VkMacOSSurfaceCreateInfoMVK;
  5.6299 -
  5.6300 -
  5.6301 -typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  5.6302 -
  5.6303 -#ifndef VK_NO_PROTOTYPES
  5.6304 -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
  5.6305 -    VkInstance                                  instance,
  5.6306 -    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
  5.6307 -    const VkAllocationCallbacks*                pAllocator,
  5.6308 -    VkSurfaceKHR*                               pSurface);
  5.6309 -#endif
  5.6310 -#endif /* VK_USE_PLATFORM_MACOS_MVK */
  5.6311 -
  5.6312 -#define VK_EXT_sampler_filter_minmax 1
  5.6313 -#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
  5.6314 -#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
  5.6315 -
  5.6316 -
  5.6317 -typedef enum VkSamplerReductionModeEXT {
  5.6318 -    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
  5.6319 -    VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
  5.6320 -    VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
  5.6321 -    VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
  5.6322 -    VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT,
  5.6323 -    VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1),
  5.6324 -    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
  5.6325 -} VkSamplerReductionModeEXT;
  5.6326 -
  5.6327 -typedef struct VkSamplerReductionModeCreateInfoEXT {
  5.6328 -    VkStructureType              sType;
  5.6329 -    const void*                  pNext;
  5.6330 -    VkSamplerReductionModeEXT    reductionMode;
  5.6331 -} VkSamplerReductionModeCreateInfoEXT;
  5.6332 -
  5.6333 -typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
  5.6334 -    VkStructureType    sType;
  5.6335 -    void*              pNext;
  5.6336 -    VkBool32           filterMinmaxSingleComponentFormats;
  5.6337 -    VkBool32           filterMinmaxImageComponentMapping;
  5.6338 -} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
  5.6339 -
  5.6340 -
  5.6341 -
  5.6342 -#define VK_AMD_gpu_shader_int16 1
  5.6343 -#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1
  5.6344 -#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
  5.6345 -
  5.6346 -
  5.6347 -#define VK_AMD_mixed_attachment_samples 1
  5.6348 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
  5.6349 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
  5.6350 -
  5.6351 -
  5.6352 -#define VK_EXT_shader_stencil_export 1
  5.6353 -#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
  5.6354 -#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
  5.6355 -
  5.6356 -
  5.6357 -#define VK_EXT_blend_operation_advanced 1
  5.6358 -#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
  5.6359 -#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
  5.6360 -
  5.6361 -
  5.6362 -typedef enum VkBlendOverlapEXT {
  5.6363 -    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
  5.6364 -    VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
  5.6365 -    VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
  5.6366 -    VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
  5.6367 -    VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT,
  5.6368 -    VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1),
  5.6369 -    VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
  5.6370 -} VkBlendOverlapEXT;
  5.6371 -
  5.6372 -typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
  5.6373 -    VkStructureType    sType;
  5.6374 -    void*              pNext;
  5.6375 -    VkBool32           advancedBlendCoherentOperations;
  5.6376 -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
  5.6377 -
  5.6378 -typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
  5.6379 -    VkStructureType    sType;
  5.6380 -    void*              pNext;
  5.6381 -    uint32_t           advancedBlendMaxColorAttachments;
  5.6382 -    VkBool32           advancedBlendIndependentBlend;
  5.6383 -    VkBool32           advancedBlendNonPremultipliedSrcColor;
  5.6384 -    VkBool32           advancedBlendNonPremultipliedDstColor;
  5.6385 -    VkBool32           advancedBlendCorrelatedOverlap;
  5.6386 -    VkBool32           advancedBlendAllOperations;
  5.6387 -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
  5.6388 -
  5.6389 -typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
  5.6390 -    VkStructureType      sType;
  5.6391 -    const void*          pNext;
  5.6392 -    VkBool32             srcPremultiplied;
  5.6393 -    VkBool32             dstPremultiplied;
  5.6394 -    VkBlendOverlapEXT    blendOverlap;
  5.6395 -} VkPipelineColorBlendAdvancedStateCreateInfoEXT;
  5.6396 -
  5.6397 -
  5.6398 -
  5.6399 -#define VK_NV_fragment_coverage_to_color 1
  5.6400 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
  5.6401 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
  5.6402 -
  5.6403 -typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
  5.6404 -
  5.6405 -typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
  5.6406 -    VkStructureType                                sType;
  5.6407 -    const void*                                    pNext;
  5.6408 -    VkPipelineCoverageToColorStateCreateFlagsNV    flags;
  5.6409 -    VkBool32                                       coverageToColorEnable;
  5.6410 -    uint32_t                                       coverageToColorLocation;
  5.6411 -} VkPipelineCoverageToColorStateCreateInfoNV;
  5.6412 -
  5.6413 -
  5.6414 -
  5.6415 -#define VK_NV_framebuffer_mixed_samples 1
  5.6416 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
  5.6417 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
  5.6418 -
  5.6419 -
  5.6420 -typedef enum VkCoverageModulationModeNV {
  5.6421 -    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
  5.6422 -    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
  5.6423 -    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
  5.6424 -    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
  5.6425 -    VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV,
  5.6426 -    VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV,
  5.6427 -    VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1),
  5.6428 -    VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
  5.6429 -} VkCoverageModulationModeNV;
  5.6430 -
  5.6431 -typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
  5.6432 -
  5.6433 -typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
  5.6434 -    VkStructureType                                   sType;
  5.6435 -    const void*                                       pNext;
  5.6436 -    VkPipelineCoverageModulationStateCreateFlagsNV    flags;
  5.6437 -    VkCoverageModulationModeNV                        coverageModulationMode;
  5.6438 -    VkBool32                                          coverageModulationTableEnable;
  5.6439 -    uint32_t                                          coverageModulationTableCount;
  5.6440 -    const float*                                      pCoverageModulationTable;
  5.6441 -} VkPipelineCoverageModulationStateCreateInfoNV;
  5.6442 -
  5.6443 -
  5.6444 -
  5.6445 -#define VK_NV_fill_rectangle 1
  5.6446 -#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
  5.6447 -#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
  5.6448 -
  5.6449 -
  5.6450 -#define VK_EXT_post_depth_coverage 1
  5.6451 -#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
  5.6452 -#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
  5.6453 -
  5.6454 -
  5.6455 -#define VK_EXT_shader_viewport_index_layer 1
  5.6456 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
  5.6457 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
  5.6458 -
  5.6459 -
  5.6460 -#ifdef __cplusplus
  5.6461 -}
  5.6462 +#include "vulkan_macos.h"
  5.6463  #endif
  5.6464  
  5.6465 +
  5.6466 +#ifdef VK_USE_PLATFORM_VI_NN
  5.6467 +#include "vulkan_vi.h"
  5.6468  #endif
  5.6469 +
  5.6470 +
  5.6471 +#ifdef VK_USE_PLATFORM_WAYLAND_KHR
  5.6472 +#include <wayland-client.h>
  5.6473 +#include "vulkan_wayland.h"
  5.6474 +#endif
  5.6475 +
  5.6476 +
  5.6477 +#ifdef VK_USE_PLATFORM_WIN32_KHR
  5.6478 +#include <windows.h>
  5.6479 +#include "vulkan_win32.h"
  5.6480 +#endif
  5.6481 +
  5.6482 +
  5.6483 +#ifdef VK_USE_PLATFORM_XCB_KHR
  5.6484 +#include <xcb/xcb.h>
  5.6485 +#include "vulkan_xcb.h"
  5.6486 +#endif
  5.6487 +
  5.6488 +
  5.6489 +#ifdef VK_USE_PLATFORM_XLIB_KHR
  5.6490 +#include <X11/Xlib.h>
  5.6491 +#include "vulkan_xlib.h"
  5.6492 +#endif
  5.6493 +
  5.6494 +
  5.6495 +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
  5.6496 +#include <X11/Xlib.h>
  5.6497 +#include <X11/extensions/Xrandr.h>
  5.6498 +#include "vulkan_xlib_xrandr.h"
  5.6499 +#endif
  5.6500 +
  5.6501 +#endif // VULKAN_H_
     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/video/khronos/vulkan/vulkan.hpp	Tue Nov 06 16:57:07 2018 -0800
     6.3 @@ -0,0 +1,53056 @@
     6.4 +// Copyright (c) 2015-2018 The Khronos Group Inc.
     6.5 +// 
     6.6 +// Licensed under the Apache License, Version 2.0 (the "License");
     6.7 +// you may not use this file except in compliance with the License.
     6.8 +// You may obtain a copy of the License at
     6.9 +// 
    6.10 +//     http://www.apache.org/licenses/LICENSE-2.0
    6.11 +// 
    6.12 +// Unless required by applicable law or agreed to in writing, software
    6.13 +// distributed under the License is distributed on an "AS IS" BASIS,
    6.14 +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    6.15 +// See the License for the specific language governing permissions and
    6.16 +// limitations under the License.
    6.17 +// 
    6.18 +// ---- Exceptions to the Apache 2.0 License: ----
    6.19 +// 
    6.20 +// As an exception, if you use this Software to generate code and portions of
    6.21 +// this Software are embedded into the generated code as a result, you may
    6.22 +// redistribute such product without providing attribution as would otherwise
    6.23 +// be required by Sections 4(a), 4(b) and 4(d) of the License.
    6.24 +// 
    6.25 +// In addition, if you combine or link code generated by this Software with
    6.26 +// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
    6.27 +// ("`Combined Software`") and if a court of competent jurisdiction determines
    6.28 +// that the patent provision (Section 3), the indemnity provision (Section 9)
    6.29 +// or other Section of the License conflicts with the conditions of the
    6.30 +// applicable GPL or LGPL license, you may retroactively and prospectively
    6.31 +// choose to deem waived or otherwise exclude such Section(s) of the License,
    6.32 +// but only in their entirety and only with respect to the Combined Software.
    6.33 +//     
    6.34 +
    6.35 +// This header is generated from the Khronos Vulkan XML API Registry.
    6.36 +
    6.37 +#ifndef VULKAN_HPP
    6.38 +#define VULKAN_HPP
    6.39 +
    6.40 +#include <algorithm>
    6.41 +#include <array>
    6.42 +#include <cstddef>
    6.43 +#include <cstdint>
    6.44 +#include <cstring>
    6.45 +#include <initializer_list>
    6.46 +#include <string>
    6.47 +#include <system_error>
    6.48 +#include <tuple>
    6.49 +#include <type_traits>
    6.50 +#include <vulkan/vulkan.h>
    6.51 +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
    6.52 +# include <memory>
    6.53 +# include <vector>
    6.54 +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
    6.55 +#if !defined(VULKAN_HPP_ASSERT)
    6.56 +# include <cassert>
    6.57 +# define VULKAN_HPP_ASSERT   assert
    6.58 +#endif
    6.59 +
    6.60 +// <tuple> includes <sys/sysmacros.h> through some other header
    6.61 +// this results in major(x) being resolved to gnu_dev_major(x)
    6.62 +// which is an expression in a constructor initializer list.
    6.63 +#if defined(major)
    6.64 +  #undef major
    6.65 +#endif
    6.66 +#if defined(minor)
    6.67 +  #undef minor
    6.68 +#endif
    6.69 +
    6.70 +// Windows defines MemoryBarrier which is deprecated and collides
    6.71 +// with the vk::MemoryBarrier struct.
    6.72 +#ifdef MemoryBarrier
    6.73 +  #undef MemoryBarrier
    6.74 +#endif
    6.75 +
    6.76 +static_assert( VK_HEADER_VERSION ==  91 , "Wrong VK_HEADER_VERSION!" );
    6.77 +
    6.78 +// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
    6.79 +// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
    6.80 +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
    6.81 +# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
    6.82 +#  define VULKAN_HPP_TYPESAFE_CONVERSION
    6.83 +# endif
    6.84 +#endif
    6.85 +
    6.86 +#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
    6.87 +# if defined(__clang__)
    6.88 +#  if __has_feature(cxx_unrestricted_unions)
    6.89 +#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    6.90 +#  endif
    6.91 +# elif defined(__GNUC__)
    6.92 +#  define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
    6.93 +#  if 40600 <= GCC_VERSION
    6.94 +#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    6.95 +#  endif
    6.96 +# elif defined(_MSC_VER)
    6.97 +#  if 1900 <= _MSC_VER
    6.98 +#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
    6.99 +#  endif
   6.100 +# endif
   6.101 +#endif
   6.102 +
   6.103 +#if !defined(VULKAN_HPP_INLINE)
   6.104 +# if defined(__clang___)
   6.105 +#  if __has_attribute(always_inline)
   6.106 +#   define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
   6.107 +#  else
   6.108 +#    define VULKAN_HPP_INLINE inline
   6.109 +#  endif
   6.110 +# elif defined(__GNUC__)
   6.111 +#  define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
   6.112 +# elif defined(_MSC_VER)
   6.113 +#  define VULKAN_HPP_INLINE inline
   6.114 +# else
   6.115 +#  define VULKAN_HPP_INLINE inline
   6.116 +# endif
   6.117 +#endif
   6.118 +
   6.119 +#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   6.120 +# define VULKAN_HPP_TYPESAFE_EXPLICIT
   6.121 +#else
   6.122 +# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
   6.123 +#endif
   6.124 +
   6.125 +#if defined(_MSC_VER) && (_MSC_VER <= 1800)
   6.126 +# define VULKAN_HPP_CONSTEXPR
   6.127 +#else
   6.128 +# define VULKAN_HPP_CONSTEXPR constexpr
   6.129 +#endif
   6.130 +
   6.131 +
   6.132 +#if !defined(VULKAN_HPP_NAMESPACE)
   6.133 +#define VULKAN_HPP_NAMESPACE vk
   6.134 +#endif
   6.135 +
   6.136 +#define VULKAN_HPP_STRINGIFY2(text) #text
   6.137 +#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
   6.138 +#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)
   6.139 +
   6.140 +namespace VULKAN_HPP_NAMESPACE
   6.141 +{
   6.142 +
   6.143 +  template <typename FlagBitsType> struct FlagTraits
   6.144 +  {
   6.145 +    enum { allFlags = 0 };
   6.146 +  };
   6.147 +
   6.148 +  template <typename BitType, typename MaskType = VkFlags>
   6.149 +  class Flags
   6.150 +  {
   6.151 +  public:
   6.152 +    VULKAN_HPP_CONSTEXPR Flags()
   6.153 +      : m_mask(0)
   6.154 +    {
   6.155 +    }
   6.156 +
   6.157 +    Flags(BitType bit)
   6.158 +      : m_mask(static_cast<MaskType>(bit))
   6.159 +    {
   6.160 +    }
   6.161 +
   6.162 +    Flags(Flags<BitType> const& rhs)
   6.163 +      : m_mask(rhs.m_mask)
   6.164 +    {
   6.165 +    }
   6.166 +
   6.167 +    explicit Flags(MaskType flags)
   6.168 +      : m_mask(flags)
   6.169 +    {
   6.170 +    }
   6.171 +
   6.172 +    Flags<BitType> & operator=(Flags<BitType> const& rhs)
   6.173 +    {
   6.174 +      m_mask = rhs.m_mask;
   6.175 +      return *this;
   6.176 +    }
   6.177 +
   6.178 +    Flags<BitType> & operator|=(Flags<BitType> const& rhs)
   6.179 +    {
   6.180 +      m_mask |= rhs.m_mask;
   6.181 +      return *this;
   6.182 +    }
   6.183 +
   6.184 +    Flags<BitType> & operator&=(Flags<BitType> const& rhs)
   6.185 +    {
   6.186 +      m_mask &= rhs.m_mask;
   6.187 +      return *this;
   6.188 +    }
   6.189 +
   6.190 +    Flags<BitType> & operator^=(Flags<BitType> const& rhs)
   6.191 +    {
   6.192 +      m_mask ^= rhs.m_mask;
   6.193 +      return *this;
   6.194 +    }
   6.195 +
   6.196 +    Flags<BitType> operator|(Flags<BitType> const& rhs) const
   6.197 +    {
   6.198 +      Flags<BitType> result(*this);
   6.199 +      result |= rhs;
   6.200 +      return result;
   6.201 +    }
   6.202 +
   6.203 +    Flags<BitType> operator&(Flags<BitType> const& rhs) const
   6.204 +    {
   6.205 +      Flags<BitType> result(*this);
   6.206 +      result &= rhs;
   6.207 +      return result;
   6.208 +    }
   6.209 +
   6.210 +    Flags<BitType> operator^(Flags<BitType> const& rhs) const
   6.211 +    {
   6.212 +      Flags<BitType> result(*this);
   6.213 +      result ^= rhs;
   6.214 +      return result;
   6.215 +    }
   6.216 +
   6.217 +    bool operator!() const
   6.218 +    {
   6.219 +      return !m_mask;
   6.220 +    }
   6.221 +
   6.222 +    Flags<BitType> operator~() const
   6.223 +    {
   6.224 +      Flags<BitType> result(*this);
   6.225 +      result.m_mask ^= FlagTraits<BitType>::allFlags;
   6.226 +      return result;
   6.227 +    }
   6.228 +
   6.229 +    bool operator==(Flags<BitType> const& rhs) const
   6.230 +    {
   6.231 +      return m_mask == rhs.m_mask;
   6.232 +    }
   6.233 +
   6.234 +    bool operator!=(Flags<BitType> const& rhs) const
   6.235 +    {
   6.236 +      return m_mask != rhs.m_mask;
   6.237 +    }
   6.238 +
   6.239 +    explicit operator bool() const
   6.240 +    {
   6.241 +      return !!m_mask;
   6.242 +    }
   6.243 +
   6.244 +    explicit operator MaskType() const
   6.245 +    {
   6.246 +        return m_mask;
   6.247 +    }
   6.248 +
   6.249 +  private:
   6.250 +    MaskType  m_mask;
   6.251 +  };
   6.252 +
   6.253 +  template <typename BitType>
   6.254 +  Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags)
   6.255 +  {
   6.256 +    return flags | bit;
   6.257 +  }
   6.258 +
   6.259 +  template <typename BitType>
   6.260 +  Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags)
   6.261 +  {
   6.262 +    return flags & bit;
   6.263 +  }
   6.264 +
   6.265 +  template <typename BitType>
   6.266 +  Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags)
   6.267 +  {
   6.268 +    return flags ^ bit;
   6.269 +  }
   6.270 +
   6.271 +
   6.272 +  template <typename RefType>
   6.273 +  class Optional
   6.274 +  {
   6.275 +  public:
   6.276 +    Optional(RefType & reference) { m_ptr = &reference; }
   6.277 +    Optional(RefType * ptr) { m_ptr = ptr; }
   6.278 +    Optional(std::nullptr_t) { m_ptr = nullptr; }
   6.279 +
   6.280 +    operator RefType*() const { return m_ptr; }
   6.281 +    RefType const* operator->() const { return m_ptr; }
   6.282 +    explicit operator bool() const { return !!m_ptr; }
   6.283 +
   6.284 +  private:
   6.285 +    RefType *m_ptr;
   6.286 +  };
   6.287 +
   6.288 +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   6.289 +  template <typename T>
   6.290 +  class ArrayProxy
   6.291 +  {
   6.292 +  public:
   6.293 +    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
   6.294 +      : m_count(0)
   6.295 +      , m_ptr(nullptr)
   6.296 +    {}
   6.297 +
   6.298 +    ArrayProxy(T & ptr)
   6.299 +      : m_count(1)
   6.300 +      , m_ptr(&ptr)
   6.301 +    {}
   6.302 +
   6.303 +    ArrayProxy(uint32_t count, T * ptr)
   6.304 +      : m_count(count)
   6.305 +      , m_ptr(ptr)
   6.306 +    {}
   6.307 +
   6.308 +    template <size_t N>
   6.309 +    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
   6.310 +      : m_count(N)
   6.311 +      , m_ptr(data.data())
   6.312 +    {}
   6.313 +
   6.314 +    template <size_t N>
   6.315 +    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
   6.316 +      : m_count(N)
   6.317 +      , m_ptr(data.data())
   6.318 +    {}
   6.319 +
   6.320 +    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
   6.321 +    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
   6.322 +      : m_count(static_cast<uint32_t>(data.size()))
   6.323 +      , m_ptr(data.data())
   6.324 +    {}
   6.325 +
   6.326 +    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
   6.327 +    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
   6.328 +      : m_count(static_cast<uint32_t>(data.size()))
   6.329 +      , m_ptr(data.data())
   6.330 +    {}
   6.331 +
   6.332 +    ArrayProxy(std::initializer_list<T> const& data)
   6.333 +      : m_count(static_cast<uint32_t>