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