1 #ifndef VULKAN_WIN32_H_
2 #define VULKAN_WIN32_H_ 1
3 
4 /*
5 ** Copyright 2015-2023 The Khronos Group Inc.
6 **
7 ** SPDX-License-Identifier: Apache-2.0
8 */
9 
10 /*
11 ** This header is generated from the Khronos Vulkan XML API Registry.
12 **
13 */
14 
15 
16 #ifdef __cplusplus
17 extern "C" {
18 #endif
19 
20 
21 
22 // VK_KHR_win32_surface is a preprocessor guard. Do not pass it to API calls.
23 #define VK_KHR_win32_surface 1
24 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
25 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
26 typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
27 typedef struct VkWin32SurfaceCreateInfoKHR {
28     VkStructureType                 sType;
29     const void*                     pNext;
30     VkWin32SurfaceCreateFlagsKHR    flags;
31     HINSTANCE                       hinstance;
32     HWND                            hwnd;
33 } VkWin32SurfaceCreateInfoKHR;
34 
35 typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
36 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
37 
38 #ifndef VK_NO_PROTOTYPES
39 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
40     VkInstance                                  instance,
41     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
42     const VkAllocationCallbacks*                pAllocator,
43     VkSurfaceKHR*                               pSurface);
44 
45 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
46     VkPhysicalDevice                            physicalDevice,
47     uint32_t                                    queueFamilyIndex);
48 #endif
49 
50 
51 // VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
52 #define VK_KHR_external_memory_win32 1
53 #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
54 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
55 typedef struct VkImportMemoryWin32HandleInfoKHR {
56     VkStructureType                       sType;
57     const void*                           pNext;
58     VkExternalMemoryHandleTypeFlagBits    handleType;
59     HANDLE                                handle;
60     LPCWSTR                               name;
61 } VkImportMemoryWin32HandleInfoKHR;
62 
63 typedef struct VkExportMemoryWin32HandleInfoKHR {
64     VkStructureType               sType;
65     const void*                   pNext;
66     const SECURITY_ATTRIBUTES*    pAttributes;
67     DWORD                         dwAccess;
68     LPCWSTR                       name;
69 } VkExportMemoryWin32HandleInfoKHR;
70 
71 typedef struct VkMemoryWin32HandlePropertiesKHR {
72     VkStructureType    sType;
73     void*              pNext;
74     uint32_t           memoryTypeBits;
75 } VkMemoryWin32HandlePropertiesKHR;
76 
77 typedef struct VkMemoryGetWin32HandleInfoKHR {
78     VkStructureType                       sType;
79     const void*                           pNext;
80     VkDeviceMemory                        memory;
81     VkExternalMemoryHandleTypeFlagBits    handleType;
82 } VkMemoryGetWin32HandleInfoKHR;
83 
84 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
85 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
86 
87 #ifndef VK_NO_PROTOTYPES
88 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
89     VkDevice                                    device,
90     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
91     HANDLE*                                     pHandle);
92 
93 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
94     VkDevice                                    device,
95     VkExternalMemoryHandleTypeFlagBits          handleType,
96     HANDLE                                      handle,
97     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
98 #endif
99 
100 
101 // VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
102 #define VK_KHR_win32_keyed_mutex 1
103 #define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
104 #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
105 typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
106     VkStructureType          sType;
107     const void*              pNext;
108     uint32_t                 acquireCount;
109     const VkDeviceMemory*    pAcquireSyncs;
110     const uint64_t*          pAcquireKeys;
111     const uint32_t*          pAcquireTimeouts;
112     uint32_t                 releaseCount;
113     const VkDeviceMemory*    pReleaseSyncs;
114     const uint64_t*          pReleaseKeys;
115 } VkWin32KeyedMutexAcquireReleaseInfoKHR;
116 
117 
118 
119 // VK_KHR_external_semaphore_win32 is a preprocessor guard. Do not pass it to API calls.
120 #define VK_KHR_external_semaphore_win32 1
121 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
122 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
123 typedef struct VkImportSemaphoreWin32HandleInfoKHR {
124     VkStructureType                          sType;
125     const void*                              pNext;
126     VkSemaphore                              semaphore;
127     VkSemaphoreImportFlags                   flags;
128     VkExternalSemaphoreHandleTypeFlagBits    handleType;
129     HANDLE                                   handle;
130     LPCWSTR                                  name;
131 } VkImportSemaphoreWin32HandleInfoKHR;
132 
133 typedef struct VkExportSemaphoreWin32HandleInfoKHR {
134     VkStructureType               sType;
135     const void*                   pNext;
136     const SECURITY_ATTRIBUTES*    pAttributes;
137     DWORD                         dwAccess;
138     LPCWSTR                       name;
139 } VkExportSemaphoreWin32HandleInfoKHR;
140 
141 typedef struct VkD3D12FenceSubmitInfoKHR {
142     VkStructureType    sType;
143     const void*        pNext;
144     uint32_t           waitSemaphoreValuesCount;
145     const uint64_t*    pWaitSemaphoreValues;
146     uint32_t           signalSemaphoreValuesCount;
147     const uint64_t*    pSignalSemaphoreValues;
148 } VkD3D12FenceSubmitInfoKHR;
149 
150 typedef struct VkSemaphoreGetWin32HandleInfoKHR {
151     VkStructureType                          sType;
152     const void*                              pNext;
153     VkSemaphore                              semaphore;
154     VkExternalSemaphoreHandleTypeFlagBits    handleType;
155 } VkSemaphoreGetWin32HandleInfoKHR;
156 
157 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
158 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
159 
160 #ifndef VK_NO_PROTOTYPES
161 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
162     VkDevice                                    device,
163     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
164 
165 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
166     VkDevice                                    device,
167     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
168     HANDLE*                                     pHandle);
169 #endif
170 
171 
172 // VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls.
173 #define VK_KHR_external_fence_win32 1
174 #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
175 #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
176 typedef struct VkImportFenceWin32HandleInfoKHR {
177     VkStructureType                      sType;
178     const void*                          pNext;
179     VkFence                              fence;
180     VkFenceImportFlags                   flags;
181     VkExternalFenceHandleTypeFlagBits    handleType;
182     HANDLE                               handle;
183     LPCWSTR                              name;
184 } VkImportFenceWin32HandleInfoKHR;
185 
186 typedef struct VkExportFenceWin32HandleInfoKHR {
187     VkStructureType               sType;
188     const void*                   pNext;
189     const SECURITY_ATTRIBUTES*    pAttributes;
190     DWORD                         dwAccess;
191     LPCWSTR                       name;
192 } VkExportFenceWin32HandleInfoKHR;
193 
194 typedef struct VkFenceGetWin32HandleInfoKHR {
195     VkStructureType                      sType;
196     const void*                          pNext;
197     VkFence                              fence;
198     VkExternalFenceHandleTypeFlagBits    handleType;
199 } VkFenceGetWin32HandleInfoKHR;
200 
201 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
202 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
203 
204 #ifndef VK_NO_PROTOTYPES
205 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
206     VkDevice                                    device,
207     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
208 
209 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
210     VkDevice                                    device,
211     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
212     HANDLE*                                     pHandle);
213 #endif
214 
215 
216 // VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
217 #define VK_NV_external_memory_win32 1
218 #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
219 #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
220 typedef struct VkImportMemoryWin32HandleInfoNV {
221     VkStructureType                      sType;
222     const void*                          pNext;
223     VkExternalMemoryHandleTypeFlagsNV    handleType;
224     HANDLE                               handle;
225 } VkImportMemoryWin32HandleInfoNV;
226 
227 typedef struct VkExportMemoryWin32HandleInfoNV {
228     VkStructureType               sType;
229     const void*                   pNext;
230     const SECURITY_ATTRIBUTES*    pAttributes;
231     DWORD                         dwAccess;
232 } VkExportMemoryWin32HandleInfoNV;
233 
234 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
235 
236 #ifndef VK_NO_PROTOTYPES
237 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
238     VkDevice                                    device,
239     VkDeviceMemory                              memory,
240     VkExternalMemoryHandleTypeFlagsNV           handleType,
241     HANDLE*                                     pHandle);
242 #endif
243 
244 
245 // VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
246 #define VK_NV_win32_keyed_mutex 1
247 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
248 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
249 typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
250     VkStructureType          sType;
251     const void*              pNext;
252     uint32_t                 acquireCount;
253     const VkDeviceMemory*    pAcquireSyncs;
254     const uint64_t*          pAcquireKeys;
255     const uint32_t*          pAcquireTimeoutMilliseconds;
256     uint32_t                 releaseCount;
257     const VkDeviceMemory*    pReleaseSyncs;
258     const uint64_t*          pReleaseKeys;
259 } VkWin32KeyedMutexAcquireReleaseInfoNV;
260 
261 
262 
263 // VK_EXT_full_screen_exclusive is a preprocessor guard. Do not pass it to API calls.
264 #define VK_EXT_full_screen_exclusive 1
265 #define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
266 #define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
267 
268 typedef enum VkFullScreenExclusiveEXT {
269     VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
270     VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
271     VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
272     VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
273     VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
274 } VkFullScreenExclusiveEXT;
275 typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
276     VkStructureType             sType;
277     void*                       pNext;
278     VkFullScreenExclusiveEXT    fullScreenExclusive;
279 } VkSurfaceFullScreenExclusiveInfoEXT;
280 
281 typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
282     VkStructureType    sType;
283     void*              pNext;
284     VkBool32           fullScreenExclusiveSupported;
285 } VkSurfaceCapabilitiesFullScreenExclusiveEXT;
286 
287 typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
288     VkStructureType    sType;
289     const void*        pNext;
290     HMONITOR           hmonitor;
291 } VkSurfaceFullScreenExclusiveWin32InfoEXT;
292 
293 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
294 typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
295 typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
296 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
297 
298 #ifndef VK_NO_PROTOTYPES
299 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
300     VkPhysicalDevice                            physicalDevice,
301     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
302     uint32_t*                                   pPresentModeCount,
303     VkPresentModeKHR*                           pPresentModes);
304 
305 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
306     VkDevice                                    device,
307     VkSwapchainKHR                              swapchain);
308 
309 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
310     VkDevice                                    device,
311     VkSwapchainKHR                              swapchain);
312 
313 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
314     VkDevice                                    device,
315     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
316     VkDeviceGroupPresentModeFlagsKHR*           pModes);
317 #endif
318 
319 
320 // VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls.
321 #define VK_NV_acquire_winrt_display 1
322 #define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
323 #define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
324 typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
325 typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
326 
327 #ifndef VK_NO_PROTOTYPES
328 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
329     VkPhysicalDevice                            physicalDevice,
330     VkDisplayKHR                                display);
331 
332 VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
333     VkPhysicalDevice                            physicalDevice,
334     uint32_t                                    deviceRelativeId,
335     VkDisplayKHR*                               pDisplay);
336 #endif
337 
338 #ifdef __cplusplus
339 }
340 #endif
341 
342 #endif
343