1 #ifndef VULKAN_WIN32_H_
2 #define VULKAN_WIN32_H_ 1
3 
4 #ifdef __cplusplus
5 extern "C" {
6 #endif
7 
8 /*
9 ** Copyright (c) 2015-2018 The Khronos Group Inc.
10 **
11 ** Licensed under the Apache License, Version 2.0 (the "License");
12 ** you may not use this file except in compliance with the License.
13 ** You may obtain a copy of the License at
14 **
15 **     http://www.apache.org/licenses/LICENSE-2.0
16 **
17 ** Unless required by applicable law or agreed to in writing, software
18 ** distributed under the License is distributed on an "AS IS" BASIS,
19 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 ** See the License for the specific language governing permissions and
21 ** limitations under the License.
22 */
23 
24 /*
25 ** This header is generated from the Khronos Vulkan XML API Registry.
26 **
27 */
28 
29 #define VK_KHR_win32_surface 1
30 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
31 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
32 
33 typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
34 
35 typedef struct VkWin32SurfaceCreateInfoKHR {
36     VkStructureType                 sType;
37     const void*                     pNext;
38     VkWin32SurfaceCreateFlagsKHR    flags;
39     HINSTANCE                       hinstance;
40     HWND                            hwnd;
41 } VkWin32SurfaceCreateInfoKHR;
42 
43 typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
44 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
45 
46 #ifndef VK_NO_PROTOTYPES
47 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
48     VkInstance                                  instance,
49     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
50     const VkAllocationCallbacks*                pAllocator,
51     VkSurfaceKHR*                               pSurface);
52 
53 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
54     VkPhysicalDevice                            physicalDevice,
55     uint32_t                                    queueFamilyIndex);
56 #endif
57 
58 #define VK_KHR_external_memory_win32 1
59 #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
60 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
61 
62 typedef struct VkImportMemoryWin32HandleInfoKHR {
63     VkStructureType                       sType;
64     const void*                           pNext;
65     VkExternalMemoryHandleTypeFlagBits    handleType;
66     HANDLE                                handle;
67     LPCWSTR                               name;
68 } VkImportMemoryWin32HandleInfoKHR;
69 
70 typedef struct VkExportMemoryWin32HandleInfoKHR {
71     VkStructureType               sType;
72     const void*                   pNext;
73     const SECURITY_ATTRIBUTES*    pAttributes;
74     DWORD                         dwAccess;
75     LPCWSTR                       name;
76 } VkExportMemoryWin32HandleInfoKHR;
77 
78 typedef struct VkMemoryWin32HandlePropertiesKHR {
79     VkStructureType    sType;
80     void*              pNext;
81     uint32_t           memoryTypeBits;
82 } VkMemoryWin32HandlePropertiesKHR;
83 
84 typedef struct VkMemoryGetWin32HandleInfoKHR {
85     VkStructureType                       sType;
86     const void*                           pNext;
87     VkDeviceMemory                        memory;
88     VkExternalMemoryHandleTypeFlagBits    handleType;
89 } VkMemoryGetWin32HandleInfoKHR;
90 
91 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
92 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
93 
94 #ifndef VK_NO_PROTOTYPES
95 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
96     VkDevice                                    device,
97     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
98     HANDLE*                                     pHandle);
99 
100 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
101     VkDevice                                    device,
102     VkExternalMemoryHandleTypeFlagBits          handleType,
103     HANDLE                                      handle,
104     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
105 #endif
106 
107 #define VK_KHR_win32_keyed_mutex 1
108 #define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
109 #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
110 
111 typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
112     VkStructureType          sType;
113     const void*              pNext;
114     uint32_t                 acquireCount;
115     const VkDeviceMemory*    pAcquireSyncs;
116     const uint64_t*          pAcquireKeys;
117     const uint32_t*          pAcquireTimeouts;
118     uint32_t                 releaseCount;
119     const VkDeviceMemory*    pReleaseSyncs;
120     const uint64_t*          pReleaseKeys;
121 } VkWin32KeyedMutexAcquireReleaseInfoKHR;
122 
123 #define VK_KHR_external_semaphore_win32 1
124 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
125 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
126 
127 typedef struct VkImportSemaphoreWin32HandleInfoKHR {
128     VkStructureType                          sType;
129     const void*                              pNext;
130     VkSemaphore                              semaphore;
131     VkSemaphoreImportFlags                   flags;
132     VkExternalSemaphoreHandleTypeFlagBits    handleType;
133     HANDLE                                   handle;
134     LPCWSTR                                  name;
135 } VkImportSemaphoreWin32HandleInfoKHR;
136 
137 typedef struct VkExportSemaphoreWin32HandleInfoKHR {
138     VkStructureType               sType;
139     const void*                   pNext;
140     const SECURITY_ATTRIBUTES*    pAttributes;
141     DWORD                         dwAccess;
142     LPCWSTR                       name;
143 } VkExportSemaphoreWin32HandleInfoKHR;
144 
145 typedef struct VkD3D12FenceSubmitInfoKHR {
146     VkStructureType    sType;
147     const void*        pNext;
148     uint32_t           waitSemaphoreValuesCount;
149     const uint64_t*    pWaitSemaphoreValues;
150     uint32_t           signalSemaphoreValuesCount;
151     const uint64_t*    pSignalSemaphoreValues;
152 } VkD3D12FenceSubmitInfoKHR;
153 
154 typedef struct VkSemaphoreGetWin32HandleInfoKHR {
155     VkStructureType                          sType;
156     const void*                              pNext;
157     VkSemaphore                              semaphore;
158     VkExternalSemaphoreHandleTypeFlagBits    handleType;
159 } VkSemaphoreGetWin32HandleInfoKHR;
160 
161 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
162 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
163 
164 #ifndef VK_NO_PROTOTYPES
165 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
166     VkDevice                                    device,
167     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
168 
169 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
170     VkDevice                                    device,
171     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
172     HANDLE*                                     pHandle);
173 #endif
174 
175 #define VK_KHR_external_fence_win32 1
176 #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
177 #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
178 
179 typedef struct VkImportFenceWin32HandleInfoKHR {
180     VkStructureType                      sType;
181     const void*                          pNext;
182     VkFence                              fence;
183     VkFenceImportFlags                   flags;
184     VkExternalFenceHandleTypeFlagBits    handleType;
185     HANDLE                               handle;
186     LPCWSTR                              name;
187 } VkImportFenceWin32HandleInfoKHR;
188 
189 typedef struct VkExportFenceWin32HandleInfoKHR {
190     VkStructureType               sType;
191     const void*                   pNext;
192     const SECURITY_ATTRIBUTES*    pAttributes;
193     DWORD                         dwAccess;
194     LPCWSTR                       name;
195 } VkExportFenceWin32HandleInfoKHR;
196 
197 typedef struct VkFenceGetWin32HandleInfoKHR {
198     VkStructureType                      sType;
199     const void*                          pNext;
200     VkFence                              fence;
201     VkExternalFenceHandleTypeFlagBits    handleType;
202 } VkFenceGetWin32HandleInfoKHR;
203 
204 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
205 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
206 
207 #ifndef VK_NO_PROTOTYPES
208 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
209     VkDevice                                    device,
210     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
211 
212 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
213     VkDevice                                    device,
214     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
215     HANDLE*                                     pHandle);
216 #endif
217 
218 #define VK_NV_external_memory_win32 1
219 #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
220 #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
221 
222 typedef struct VkImportMemoryWin32HandleInfoNV {
223     VkStructureType                      sType;
224     const void*                          pNext;
225     VkExternalMemoryHandleTypeFlagsNV    handleType;
226     HANDLE                               handle;
227 } VkImportMemoryWin32HandleInfoNV;
228 
229 typedef struct VkExportMemoryWin32HandleInfoNV {
230     VkStructureType               sType;
231     const void*                   pNext;
232     const SECURITY_ATTRIBUTES*    pAttributes;
233     DWORD                         dwAccess;
234 } VkExportMemoryWin32HandleInfoNV;
235 
236 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
237 
238 #ifndef VK_NO_PROTOTYPES
239 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
240     VkDevice                                    device,
241     VkDeviceMemory                              memory,
242     VkExternalMemoryHandleTypeFlagsNV           handleType,
243     HANDLE*                                     pHandle);
244 #endif
245 
246 #define VK_NV_win32_keyed_mutex 1
247 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
248 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
249 
250 typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
251     VkStructureType          sType;
252     const void*              pNext;
253     uint32_t                 acquireCount;
254     const VkDeviceMemory*    pAcquireSyncs;
255     const uint64_t*          pAcquireKeys;
256     const uint32_t*          pAcquireTimeoutMilliseconds;
257     uint32_t                 releaseCount;
258     const VkDeviceMemory*    pReleaseSyncs;
259     const uint64_t*          pReleaseKeys;
260 } VkWin32KeyedMutexAcquireReleaseInfoNV;
261 
262 #ifdef __cplusplus
263 }
264 #endif
265 
266 #endif
267