VirtualBox

source: vbox/trunk/src/VBox/Additions/3D/mesa/mesa-24.0.2/include/vulkan/vulkan_win32.h

最後變更 在這個檔案是 103996,由 vboxsync 提交於 12 月 前

Additions/3D/mesa: export mesa-24.0.2 to OSE. bugref:10606
  • 屬性 svn:eol-style 設為 native
檔案大小: 14.8 KB
行 
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
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
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette