1#ifndef VULKAN_WIN32_H_
2#define VULKAN_WIN32_H_ 1
3
4/*
5** Copyright 2015-2024 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
17extern "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"
26typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
27typedef struct VkWin32SurfaceCreateInfoKHR {
28    VkStructureType                 sType;
29    const void*                     pNext;
30    VkWin32SurfaceCreateFlagsKHR    flags;
31    HINSTANCE                       hinstance;
32    HWND                            hwnd;
33} VkWin32SurfaceCreateInfoKHR;
34
35typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
36typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
37
38#ifndef VK_NO_PROTOTYPES
39VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
40    VkInstance                                  instance,
41    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
42    const VkAllocationCallbacks*                pAllocator,
43    VkSurfaceKHR*                               pSurface);
44
45VKAPI_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"
55typedef struct VkImportMemoryWin32HandleInfoKHR {
56    VkStructureType                       sType;
57    const void*                           pNext;
58    VkExternalMemoryHandleTypeFlagBits    handleType;
59    HANDLE                                handle;
60    LPCWSTR                               name;
61} VkImportMemoryWin32HandleInfoKHR;
62
63typedef struct VkExportMemoryWin32HandleInfoKHR {
64    VkStructureType               sType;
65    const void*                   pNext;
66    const SECURITY_ATTRIBUTES*    pAttributes;
67    DWORD                         dwAccess;
68    LPCWSTR                       name;
69} VkExportMemoryWin32HandleInfoKHR;
70
71typedef struct VkMemoryWin32HandlePropertiesKHR {
72    VkStructureType    sType;
73    void*              pNext;
74    uint32_t           memoryTypeBits;
75} VkMemoryWin32HandlePropertiesKHR;
76
77typedef struct VkMemoryGetWin32HandleInfoKHR {
78    VkStructureType                       sType;
79    const void*                           pNext;
80    VkDeviceMemory                        memory;
81    VkExternalMemoryHandleTypeFlagBits    handleType;
82} VkMemoryGetWin32HandleInfoKHR;
83
84typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
85typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
86
87#ifndef VK_NO_PROTOTYPES
88VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
89    VkDevice                                    device,
90    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
91    HANDLE*                                     pHandle);
92
93VKAPI_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"
105typedef 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"
123typedef 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
133typedef struct VkExportSemaphoreWin32HandleInfoKHR {
134    VkStructureType               sType;
135    const void*                   pNext;
136    const SECURITY_ATTRIBUTES*    pAttributes;
137    DWORD                         dwAccess;
138    LPCWSTR                       name;
139} VkExportSemaphoreWin32HandleInfoKHR;
140
141typedef 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
150typedef struct VkSemaphoreGetWin32HandleInfoKHR {
151    VkStructureType                          sType;
152    const void*                              pNext;
153    VkSemaphore                              semaphore;
154    VkExternalSemaphoreHandleTypeFlagBits    handleType;
155} VkSemaphoreGetWin32HandleInfoKHR;
156
157typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
158typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
159
160#ifndef VK_NO_PROTOTYPES
161VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
162    VkDevice                                    device,
163    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
164
165VKAPI_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"
176typedef 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
186typedef struct VkExportFenceWin32HandleInfoKHR {
187    VkStructureType               sType;
188    const void*                   pNext;
189    const SECURITY_ATTRIBUTES*    pAttributes;
190    DWORD                         dwAccess;
191    LPCWSTR                       name;
192} VkExportFenceWin32HandleInfoKHR;
193
194typedef struct VkFenceGetWin32HandleInfoKHR {
195    VkStructureType                      sType;
196    const void*                          pNext;
197    VkFence                              fence;
198    VkExternalFenceHandleTypeFlagBits    handleType;
199} VkFenceGetWin32HandleInfoKHR;
200
201typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
202typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
203
204#ifndef VK_NO_PROTOTYPES
205VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
206    VkDevice                                    device,
207    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
208
209VKAPI_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"
220typedef struct VkImportMemoryWin32HandleInfoNV {
221    VkStructureType                      sType;
222    const void*                          pNext;
223    VkExternalMemoryHandleTypeFlagsNV    handleType;
224    HANDLE                               handle;
225} VkImportMemoryWin32HandleInfoNV;
226
227typedef struct VkExportMemoryWin32HandleInfoNV {
228    VkStructureType               sType;
229    const void*                   pNext;
230    const SECURITY_ATTRIBUTES*    pAttributes;
231    DWORD                         dwAccess;
232} VkExportMemoryWin32HandleInfoNV;
233
234typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
235
236#ifndef VK_NO_PROTOTYPES
237VKAPI_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"
249typedef 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
268typedef 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;
275typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
276    VkStructureType             sType;
277    void*                       pNext;
278    VkFullScreenExclusiveEXT    fullScreenExclusive;
279} VkSurfaceFullScreenExclusiveInfoEXT;
280
281typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
282    VkStructureType    sType;
283    void*              pNext;
284    VkBool32           fullScreenExclusiveSupported;
285} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
286
287typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
288    VkStructureType    sType;
289    const void*        pNext;
290    HMONITOR           hmonitor;
291} VkSurfaceFullScreenExclusiveWin32InfoEXT;
292
293typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
294typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
295typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
296typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
297
298#ifndef VK_NO_PROTOTYPES
299VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
300    VkPhysicalDevice                            physicalDevice,
301    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
302    uint32_t*                                   pPresentModeCount,
303    VkPresentModeKHR*                           pPresentModes);
304
305VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
306    VkDevice                                    device,
307    VkSwapchainKHR                              swapchain);
308
309VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
310    VkDevice                                    device,
311    VkSwapchainKHR                              swapchain);
312
313VKAPI_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"
324typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
325typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
326
327#ifndef VK_NO_PROTOTYPES
328VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
329    VkPhysicalDevice                            physicalDevice,
330    VkDisplayKHR                                display);
331
332VKAPI_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