Mercurial > games > semicongine

comparison fuhtark_test/Vulkan-Headers-1.4.334/include/vulkan/vulkan_win32.h @ 1501:f40d9d814c08 default tip main

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: correct vulkan-api generator
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 23:34:29 +0700
parents
children
comparison
equal deleted inserted replaced
1500:91c8c3b7cbf0 1501:f40d9d814c08
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