CoCalc -- vulkan

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/include/vulkan/vulkan_win32.h
⁴⁵⁵⁰ views
1
#ifndef VULKAN_WIN32_H_
2
#define VULKAN_WIN32_H_ 1
3

4
/*
5
** Copyright 2015-2021 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
#define VK_KHR_win32_surface 1
23
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
24
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
25
typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
26
typedef struct VkWin32SurfaceCreateInfoKHR {
27
    VkStructureType                 sType;
28
    const void*                     pNext;
29
    VkWin32SurfaceCreateFlagsKHR    flags;
30
    HINSTANCE                       hinstance;
31
    HWND                            hwnd;
32
} VkWin32SurfaceCreateInfoKHR;
33

34
typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
35
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
36

37
#ifndef VK_NO_PROTOTYPES
38
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
39
    VkInstance                                  instance,
40
    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
41
    const VkAllocationCallbacks*                pAllocator,
42
    VkSurfaceKHR*                               pSurface);
43

44
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
45
    VkPhysicalDevice                            physicalDevice,
46
    uint32_t                                    queueFamilyIndex);
47
#endif
48

49

50
#define VK_KHR_external_memory_win32 1
51
#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
52
#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
53
typedef struct VkImportMemoryWin32HandleInfoKHR {
54
    VkStructureType                       sType;
55
    const void*                           pNext;
56
    VkExternalMemoryHandleTypeFlagBits    handleType;
57
    HANDLE                                handle;
58
    LPCWSTR                               name;
59
} VkImportMemoryWin32HandleInfoKHR;
60

61
typedef struct VkExportMemoryWin32HandleInfoKHR {
62
    VkStructureType               sType;
63
    const void*                   pNext;
64
    const SECURITY_ATTRIBUTES*    pAttributes;
65
    DWORD                         dwAccess;
66
    LPCWSTR                       name;
67
} VkExportMemoryWin32HandleInfoKHR;
68

69
typedef struct VkMemoryWin32HandlePropertiesKHR {
70
    VkStructureType    sType;
71
    void*              pNext;
72
    uint32_t           memoryTypeBits;
73
} VkMemoryWin32HandlePropertiesKHR;
74

75
typedef struct VkMemoryGetWin32HandleInfoKHR {
76
    VkStructureType                       sType;
77
    const void*                           pNext;
78
    VkDeviceMemory                        memory;
79
    VkExternalMemoryHandleTypeFlagBits    handleType;
80
} VkMemoryGetWin32HandleInfoKHR;
81

82
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
83
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
84

85
#ifndef VK_NO_PROTOTYPES
86
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
87
    VkDevice                                    device,
88
    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
89
    HANDLE*                                     pHandle);
90

91
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
92
    VkDevice                                    device,
93
    VkExternalMemoryHandleTypeFlagBits          handleType,
94
    HANDLE                                      handle,
95
    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
96
#endif
97

98

99
#define VK_KHR_win32_keyed_mutex 1
100
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
101
#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
102
typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
103
    VkStructureType          sType;
104
    const void*              pNext;
105
    uint32_t                 acquireCount;
106
    const VkDeviceMemory*    pAcquireSyncs;
107
    const uint64_t*          pAcquireKeys;
108
    const uint32_t*          pAcquireTimeouts;
109
    uint32_t                 releaseCount;
110
    const VkDeviceMemory*    pReleaseSyncs;
111
    const uint64_t*          pReleaseKeys;
112
} VkWin32KeyedMutexAcquireReleaseInfoKHR;
113

114

115

116
#define VK_KHR_external_semaphore_win32 1
117
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
118
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
119
typedef struct VkImportSemaphoreWin32HandleInfoKHR {
120
    VkStructureType                          sType;
121
    const void*                              pNext;
122
    VkSemaphore                              semaphore;
123
    VkSemaphoreImportFlags                   flags;
124
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
125
    HANDLE                                   handle;
126
    LPCWSTR                                  name;
127
} VkImportSemaphoreWin32HandleInfoKHR;
128

129
typedef struct VkExportSemaphoreWin32HandleInfoKHR {
130
    VkStructureType               sType;
131
    const void*                   pNext;
132
    const SECURITY_ATTRIBUTES*    pAttributes;
133
    DWORD                         dwAccess;
134
    LPCWSTR                       name;
135
} VkExportSemaphoreWin32HandleInfoKHR;
136

137
typedef struct VkD3D12FenceSubmitInfoKHR {
138
    VkStructureType    sType;
139
    const void*        pNext;
140
    uint32_t           waitSemaphoreValuesCount;
141
    const uint64_t*    pWaitSemaphoreValues;
142
    uint32_t           signalSemaphoreValuesCount;
143
    const uint64_t*    pSignalSemaphoreValues;
144
} VkD3D12FenceSubmitInfoKHR;
145

146
typedef struct VkSemaphoreGetWin32HandleInfoKHR {
147
    VkStructureType                          sType;
148
    const void*                              pNext;
149
    VkSemaphore                              semaphore;
150
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
151
} VkSemaphoreGetWin32HandleInfoKHR;
152

153
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
154
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
155

156
#ifndef VK_NO_PROTOTYPES
157
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
158
    VkDevice                                    device,
159
    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
160

161
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
162
    VkDevice                                    device,
163
    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
164
    HANDLE*                                     pHandle);
165
#endif
166

167

168
#define VK_KHR_external_fence_win32 1
169
#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
170
#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
171
typedef struct VkImportFenceWin32HandleInfoKHR {
172
    VkStructureType                      sType;
173
    const void*                          pNext;
174
    VkFence                              fence;
175
    VkFenceImportFlags                   flags;
176
    VkExternalFenceHandleTypeFlagBits    handleType;
177
    HANDLE                               handle;
178
    LPCWSTR                              name;
179
} VkImportFenceWin32HandleInfoKHR;
180

181
typedef struct VkExportFenceWin32HandleInfoKHR {
182
    VkStructureType               sType;
183
    const void*                   pNext;
184
    const SECURITY_ATTRIBUTES*    pAttributes;
185
    DWORD                         dwAccess;
186
    LPCWSTR                       name;
187
} VkExportFenceWin32HandleInfoKHR;
188

189
typedef struct VkFenceGetWin32HandleInfoKHR {
190
    VkStructureType                      sType;
191
    const void*                          pNext;
192
    VkFence                              fence;
193
    VkExternalFenceHandleTypeFlagBits    handleType;
194
} VkFenceGetWin32HandleInfoKHR;
195

196
typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
197
typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
198

199
#ifndef VK_NO_PROTOTYPES
200
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
201
    VkDevice                                    device,
202
    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
203

204
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
205
    VkDevice                                    device,
206
    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
207
    HANDLE*                                     pHandle);
208
#endif
209

210

211
#define VK_NV_external_memory_win32 1
212
#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
213
#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
214
typedef struct VkImportMemoryWin32HandleInfoNV {
215
    VkStructureType                      sType;
216
    const void*                          pNext;
217
    VkExternalMemoryHandleTypeFlagsNV    handleType;
218
    HANDLE                               handle;
219
} VkImportMemoryWin32HandleInfoNV;
220

221
typedef struct VkExportMemoryWin32HandleInfoNV {
222
    VkStructureType               sType;
223
    const void*                   pNext;
224
    const SECURITY_ATTRIBUTES*    pAttributes;
225
    DWORD                         dwAccess;
226
} VkExportMemoryWin32HandleInfoNV;
227

228
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
229

230
#ifndef VK_NO_PROTOTYPES
231
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
232
    VkDevice                                    device,
233
    VkDeviceMemory                              memory,
234
    VkExternalMemoryHandleTypeFlagsNV           handleType,
235
    HANDLE*                                     pHandle);
236
#endif
237

238

239
#define VK_NV_win32_keyed_mutex 1
240
#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
241
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
242
typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
243
    VkStructureType          sType;
244
    const void*              pNext;
245
    uint32_t                 acquireCount;
246
    const VkDeviceMemory*    pAcquireSyncs;
247
    const uint64_t*          pAcquireKeys;
248
    const uint32_t*          pAcquireTimeoutMilliseconds;
249
    uint32_t                 releaseCount;
250
    const VkDeviceMemory*    pReleaseSyncs;
251
    const uint64_t*          pReleaseKeys;
252
} VkWin32KeyedMutexAcquireReleaseInfoNV;
253

254

255

256
#define VK_EXT_full_screen_exclusive 1
257
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
258
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
259

260
typedef enum VkFullScreenExclusiveEXT {
261
    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
262
    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
263
    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
264
    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
265
    VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
266
} VkFullScreenExclusiveEXT;
267
typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
268
    VkStructureType             sType;
269
    void*                       pNext;
270
    VkFullScreenExclusiveEXT    fullScreenExclusive;
271
} VkSurfaceFullScreenExclusiveInfoEXT;
272

273
typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
274
    VkStructureType    sType;
275
    void*              pNext;
276
    VkBool32           fullScreenExclusiveSupported;
277
} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
278

279
typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
280
    VkStructureType    sType;
281
    const void*        pNext;
282
    HMONITOR           hmonitor;
283
} VkSurfaceFullScreenExclusiveWin32InfoEXT;
284

285
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
286
typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
287
typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
288
typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
289

290
#ifndef VK_NO_PROTOTYPES
291
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
292
    VkPhysicalDevice                            physicalDevice,
293
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
294
    uint32_t*                                   pPresentModeCount,
295
    VkPresentModeKHR*                           pPresentModes);
296

297
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
298
    VkDevice                                    device,
299
    VkSwapchainKHR                              swapchain);
300

301
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
302
    VkDevice                                    device,
303
    VkSwapchainKHR                              swapchain);
304

305
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
306
    VkDevice                                    device,
307
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
308
    VkDeviceGroupPresentModeFlagsKHR*           pModes);
309
#endif
310

311
#ifdef __cplusplus
312
}
313
#endif
314

315
#endif
316

317
Product

Resources

Company
