Mercurial > games > semicongine

comparison semiconginev2/rendering/vulkan/api.nim @ 1218:56781cc0fc7c compiletime-tests

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: renamge main package
author sam <sam@basx.dev>
date Wed, 17 Jul 2024 21:01:37 +0700
parents semicongine/rendering/vulkan/api.nim@ba1af13233ee
children a3fa15c25026
comparison
equal deleted inserted replaced
1217:f819a874058f 1218:56781cc0fc7c
1 type
2 VkHandle* = distinct uint
3 VkNonDispatchableHandle* = distinct uint
4 when defined(linux):
5 let vulkanLib* = loadLib("libvulkan.so.1")
6 when defined(windows):
7 let vulkanLib* = loadLib("vulkan-1.dll")
8 if vulkanLib == nil:
9 raise newException(Exception, "Unable to load vulkan library")
10 func VK_MAKE_API_VERSION*(variant: uint32, major: uint32, minor: uint32, patch: uint32): uint32 {.compileTime.} =
11 (variant shl 29) or (major shl 22) or (minor shl 12) or patch
12
13 template checkVkResult*(call: untyped) =
14 when defined(release):
15 discard call
16 else:
17 # yes, a bit cheap, but this is only for nice debug output
18 var callstr = astToStr(call).replace("\n", "")
19 while callstr.find(" ") >= 0:
20 callstr = callstr.replace(" ", " ")
21 debug "Calling vulkan: ", callstr
22 let value = call
23 if value != VK_SUCCESS:
24 error "Vulkan error: ", astToStr(call), " returned ", $value
25 raise newException(Exception, "Vulkan error: " & astToStr(call) &
26 " returned " & $value)
27 # custom enum iteration (for enum values > 2^16)
28 macro enumFullRange(a: typed): untyped =
29 newNimNode(nnkBracket).add(a.getType[1][1..^1])
30
31 iterator items*[T: HoleyEnum](E: typedesc[T]): T =
32 for a in enumFullRange(E): yield a
33 const
34 VK_MAX_PHYSICAL_DEVICE_NAME_SIZE*: uint32 = 256
35 VK_UUID_SIZE*: uint32 = 16
36 VK_LUID_SIZE*: uint32 = 8
37 VK_LUID_SIZE_KHR* = VK_LUID_SIZE
38 VK_MAX_EXTENSION_NAME_SIZE*: uint32 = 256
39 VK_MAX_DESCRIPTION_SIZE*: uint32 = 256
40 VK_MAX_MEMORY_TYPES*: uint32 = 32
41 VK_MAX_MEMORY_HEAPS*: uint32 = 16
42 VK_LOD_CLAMP_NONE*: float32 = 1000.0F
43 VK_REMAINING_MIP_LEVELS*: uint32 = not 0'u32
44 VK_REMAINING_ARRAY_LAYERS*: uint32 = not 0'u32
45 VK_REMAINING_3D_SLICES_EXT*: uint32 = not 0'u32
46 VK_WHOLE_SIZE*: uint64 = not 0'u64
47 VK_ATTACHMENT_UNUSED*: uint32 = not 0'u32
48 VK_TRUE*: uint32 = 1
49 VK_FALSE*: uint32 = 0
50 VK_QUEUE_FAMILY_IGNORED*: uint32 = not 0'u32
51 VK_QUEUE_FAMILY_EXTERNAL*: uint32 = not 1'u32
52 VK_QUEUE_FAMILY_EXTERNAL_KHR* = VK_QUEUE_FAMILY_EXTERNAL
53 VK_QUEUE_FAMILY_FOREIGN_EXT*: uint32 = not 2'u32
54 VK_SUBPASS_EXTERNAL*: uint32 = not 0'u32
55 VK_MAX_DEVICE_GROUP_SIZE*: uint32 = 32
56 VK_MAX_DEVICE_GROUP_SIZE_KHR* = VK_MAX_DEVICE_GROUP_SIZE
57 VK_MAX_DRIVER_NAME_SIZE*: uint32 = 256
58 VK_MAX_DRIVER_NAME_SIZE_KHR* = VK_MAX_DRIVER_NAME_SIZE
59 VK_MAX_DRIVER_INFO_SIZE*: uint32 = 256
60 VK_MAX_DRIVER_INFO_SIZE_KHR* = VK_MAX_DRIVER_INFO_SIZE
61 VK_SHADER_UNUSED_KHR*: uint32 = not 0'u32
62 VK_SHADER_UNUSED_NV* = VK_SHADER_UNUSED_KHR
63 VK_MAX_GLOBAL_PRIORITY_SIZE_KHR*: uint32 = 16
64 VK_MAX_GLOBAL_PRIORITY_SIZE_EXT* = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
65 VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT*: uint32 = 32
66 type
67 ANativeWindow* = object
68 AHardwareBuffer* = object
69 CAMetalLayer* = object
70 MTLDevice_id* = object
71 MTLCommandQueue_id* = object
72 MTLBuffer_id* = object
73 MTLTexture_id* = object
74 MTLSharedEvent_id* = object
75 IOSurfaceRef* = object
76 VkSampleMask* = uint32
77 VkBool32* = uint32
78 VkFlags* = uint32
79 VkFlags64* = uint64
80 VkDeviceSize* = uint64
81 VkDeviceAddress* = uint64
82 VkInstance* = distinct VkHandle
83 VkPhysicalDevice* = distinct VkHandle
84 VkDevice* = distinct VkHandle
85 VkQueue* = distinct VkHandle
86 VkCommandBuffer* = distinct VkHandle
87 VkDeviceMemory* = distinct VkNonDispatchableHandle
88 VkCommandPool* = distinct VkNonDispatchableHandle
89 VkBuffer* = distinct VkNonDispatchableHandle
90 VkBufferView* = distinct VkNonDispatchableHandle
91 VkImage* = distinct VkNonDispatchableHandle
92 VkImageView* = distinct VkNonDispatchableHandle
93 VkShaderModule* = distinct VkNonDispatchableHandle
94 VkPipeline* = distinct VkNonDispatchableHandle
95 VkPipelineLayout* = distinct VkNonDispatchableHandle
96 VkSampler* = distinct VkNonDispatchableHandle
97 VkDescriptorSet* = distinct VkNonDispatchableHandle
98 VkDescriptorSetLayout* = distinct VkNonDispatchableHandle
99 VkDescriptorPool* = distinct VkNonDispatchableHandle
100 VkFence* = distinct VkNonDispatchableHandle
101 VkSemaphore* = distinct VkNonDispatchableHandle
102 VkEvent* = distinct VkNonDispatchableHandle
103 VkQueryPool* = distinct VkNonDispatchableHandle
104 VkFramebuffer* = distinct VkNonDispatchableHandle
105 VkRenderPass* = distinct VkNonDispatchableHandle
106 VkPipelineCache* = distinct VkNonDispatchableHandle
107 VkIndirectCommandsLayoutNV* = distinct VkNonDispatchableHandle
108 VkDescriptorUpdateTemplate* = distinct VkNonDispatchableHandle
109 VkSamplerYcbcrConversion* = distinct VkNonDispatchableHandle
110 VkValidationCacheEXT* = distinct VkNonDispatchableHandle
111 VkAccelerationStructureKHR* = distinct VkNonDispatchableHandle
112 VkAccelerationStructureNV* = distinct VkNonDispatchableHandle
113 VkPerformanceConfigurationINTEL* = distinct VkNonDispatchableHandle
114 VkBufferCollectionFUCHSIA* = distinct VkNonDispatchableHandle
115 VkDeferredOperationKHR* = distinct VkNonDispatchableHandle
116 VkPrivateDataSlot* = distinct VkNonDispatchableHandle
117 VkCuModuleNVX* = distinct VkNonDispatchableHandle
118 VkCuFunctionNVX* = distinct VkNonDispatchableHandle
119 VkOpticalFlowSessionNV* = distinct VkNonDispatchableHandle
120 VkMicromapEXT* = distinct VkNonDispatchableHandle
121 VkDisplayKHR* = distinct VkNonDispatchableHandle
122 VkDisplayModeKHR* = distinct VkNonDispatchableHandle
123 VkSurfaceKHR* = distinct VkNonDispatchableHandle
124 VkSwapchainKHR* = distinct VkNonDispatchableHandle
125 VkDebugReportCallbackEXT* = distinct VkNonDispatchableHandle
126 VkDebugUtilsMessengerEXT* = distinct VkNonDispatchableHandle
127 VkVideoSessionKHR* = distinct VkNonDispatchableHandle
128 VkVideoSessionParametersKHR* = distinct VkNonDispatchableHandle
129 VkSemaphoreSciSyncPoolNV* = distinct VkNonDispatchableHandle
130 VkRemoteAddressNV* = pointer
131 proc `$`*(handle: VkInstance): string = "VkInstance(" & $(uint(handle)) & ")"
132 proc Valid*(handle: VkInstance): bool = uint(handle) != 0
133 proc Reset*(handle: var VkInstance) = handle = VkInstance(0)
134 proc `==`*(a, b: VkInstance): bool = uint(a) == uint(b)
135 proc `$`*(handle: VkPhysicalDevice): string = "VkPhysicalDevice(" & $(uint(handle)) & ")"
136 proc Valid*(handle: VkPhysicalDevice): bool = uint(handle) != 0
137 proc Reset*(handle: var VkPhysicalDevice) = handle = VkPhysicalDevice(0)
138 proc `==`*(a, b: VkPhysicalDevice): bool = uint(a) == uint(b)
139 proc `$`*(handle: VkDevice): string = "VkDevice(" & $(uint(handle)) & ")"
140 proc Valid*(handle: VkDevice): bool = uint(handle) != 0
141 proc Reset*(handle: var VkDevice) = handle = VkDevice(0)
142 proc `==`*(a, b: VkDevice): bool = uint(a) == uint(b)
143 proc `$`*(handle: VkQueue): string = "VkQueue(" & $(uint(handle)) & ")"
144 proc Valid*(handle: VkQueue): bool = uint(handle) != 0
145 proc Reset*(handle: var VkQueue) = handle = VkQueue(0)
146 proc `==`*(a, b: VkQueue): bool = uint(a) == uint(b)
147 proc `$`*(handle: VkCommandBuffer): string = "VkCommandBuffer(" & $(uint(handle)) & ")"
148 proc Valid*(handle: VkCommandBuffer): bool = uint(handle) != 0
149 proc Reset*(handle: var VkCommandBuffer) = handle = VkCommandBuffer(0)
150 proc `==`*(a, b: VkCommandBuffer): bool = uint(a) == uint(b)
151 proc `$`*(handle: VkDeviceMemory): string = "VkDeviceMemory(" & $(uint(handle)) & ")"
152 proc Valid*(handle: VkDeviceMemory): bool = uint(handle) != 0
153 proc Reset*(handle: var VkDeviceMemory) = handle = VkDeviceMemory(0)
154 proc `==`*(a, b: VkDeviceMemory): bool = uint(a) == uint(b)
155 proc `$`*(handle: VkCommandPool): string = "VkCommandPool(" & $(uint(handle)) & ")"
156 proc Valid*(handle: VkCommandPool): bool = uint(handle) != 0
157 proc Reset*(handle: var VkCommandPool) = handle = VkCommandPool(0)
158 proc `==`*(a, b: VkCommandPool): bool = uint(a) == uint(b)
159 proc `$`*(handle: VkBuffer): string = "VkBuffer(" & $(uint(handle)) & ")"
160 proc Valid*(handle: VkBuffer): bool = uint(handle) != 0
161 proc Reset*(handle: var VkBuffer) = handle = VkBuffer(0)
162 proc `==`*(a, b: VkBuffer): bool = uint(a) == uint(b)
163 proc `$`*(handle: VkBufferView): string = "VkBufferView(" & $(uint(handle)) & ")"
164 proc Valid*(handle: VkBufferView): bool = uint(handle) != 0
165 proc Reset*(handle: var VkBufferView) = handle = VkBufferView(0)
166 proc `==`*(a, b: VkBufferView): bool = uint(a) == uint(b)
167 proc `$`*(handle: VkImage): string = "VkImage(" & $(uint(handle)) & ")"
168 proc Valid*(handle: VkImage): bool = uint(handle) != 0
169 proc Reset*(handle: var VkImage) = handle = VkImage(0)
170 proc `==`*(a, b: VkImage): bool = uint(a) == uint(b)
171 proc `$`*(handle: VkImageView): string = "VkImageView(" & $(uint(handle)) & ")"
172 proc Valid*(handle: VkImageView): bool = uint(handle) != 0
173 proc Reset*(handle: var VkImageView) = handle = VkImageView(0)
174 proc `==`*(a, b: VkImageView): bool = uint(a) == uint(b)
175 proc `$`*(handle: VkShaderModule): string = "VkShaderModule(" & $(uint(handle)) & ")"
176 proc Valid*(handle: VkShaderModule): bool = uint(handle) != 0
177 proc Reset*(handle: var VkShaderModule) = handle = VkShaderModule(0)
178 proc `==`*(a, b: VkShaderModule): bool = uint(a) == uint(b)
179 proc `$`*(handle: VkPipeline): string = "VkPipeline(" & $(uint(handle)) & ")"
180 proc Valid*(handle: VkPipeline): bool = uint(handle) != 0
181 proc Reset*(handle: var VkPipeline) = handle = VkPipeline(0)
182 proc `==`*(a, b: VkPipeline): bool = uint(a) == uint(b)
183 proc `$`*(handle: VkPipelineLayout): string = "VkPipelineLayout(" & $(uint(handle)) & ")"
184 proc Valid*(handle: VkPipelineLayout): bool = uint(handle) != 0
185 proc Reset*(handle: var VkPipelineLayout) = handle = VkPipelineLayout(0)
186 proc `==`*(a, b: VkPipelineLayout): bool = uint(a) == uint(b)
187 proc `$`*(handle: VkSampler): string = "VkSampler(" & $(uint(handle)) & ")"
188 proc Valid*(handle: VkSampler): bool = uint(handle) != 0
189 proc Reset*(handle: var VkSampler) = handle = VkSampler(0)
190 proc `==`*(a, b: VkSampler): bool = uint(a) == uint(b)
191 proc `$`*(handle: VkDescriptorSet): string = "VkDescriptorSet(" & $(uint(handle)) & ")"
192 proc Valid*(handle: VkDescriptorSet): bool = uint(handle) != 0
193 proc Reset*(handle: var VkDescriptorSet) = handle = VkDescriptorSet(0)
194 proc `==`*(a, b: VkDescriptorSet): bool = uint(a) == uint(b)
195 proc `$`*(handle: VkDescriptorSetLayout): string = "VkDescriptorSetLayout(" & $(uint(handle)) & ")"
196 proc Valid*(handle: VkDescriptorSetLayout): bool = uint(handle) != 0
197 proc Reset*(handle: var VkDescriptorSetLayout) = handle = VkDescriptorSetLayout(0)
198 proc `==`*(a, b: VkDescriptorSetLayout): bool = uint(a) == uint(b)
199 proc `$`*(handle: VkDescriptorPool): string = "VkDescriptorPool(" & $(uint(handle)) & ")"
200 proc Valid*(handle: VkDescriptorPool): bool = uint(handle) != 0
201 proc Reset*(handle: var VkDescriptorPool) = handle = VkDescriptorPool(0)
202 proc `==`*(a, b: VkDescriptorPool): bool = uint(a) == uint(b)
203 proc `$`*(handle: VkFence): string = "VkFence(" & $(uint(handle)) & ")"
204 proc Valid*(handle: VkFence): bool = uint(handle) != 0
205 proc Reset*(handle: var VkFence) = handle = VkFence(0)
206 proc `==`*(a, b: VkFence): bool = uint(a) == uint(b)
207 proc `$`*(handle: VkSemaphore): string = "VkSemaphore(" & $(uint(handle)) & ")"
208 proc Valid*(handle: VkSemaphore): bool = uint(handle) != 0
209 proc Reset*(handle: var VkSemaphore) = handle = VkSemaphore(0)
210 proc `==`*(a, b: VkSemaphore): bool = uint(a) == uint(b)
211 proc `$`*(handle: VkEvent): string = "VkEvent(" & $(uint(handle)) & ")"
212 proc Valid*(handle: VkEvent): bool = uint(handle) != 0
213 proc Reset*(handle: var VkEvent) = handle = VkEvent(0)
214 proc `==`*(a, b: VkEvent): bool = uint(a) == uint(b)
215 proc `$`*(handle: VkQueryPool): string = "VkQueryPool(" & $(uint(handle)) & ")"
216 proc Valid*(handle: VkQueryPool): bool = uint(handle) != 0
217 proc Reset*(handle: var VkQueryPool) = handle = VkQueryPool(0)
218 proc `==`*(a, b: VkQueryPool): bool = uint(a) == uint(b)
219 proc `$`*(handle: VkFramebuffer): string = "VkFramebuffer(" & $(uint(handle)) & ")"
220 proc Valid*(handle: VkFramebuffer): bool = uint(handle) != 0
221 proc Reset*(handle: var VkFramebuffer) = handle = VkFramebuffer(0)
222 proc `==`*(a, b: VkFramebuffer): bool = uint(a) == uint(b)
223 proc `$`*(handle: VkRenderPass): string = "VkRenderPass(" & $(uint(handle)) & ")"
224 proc Valid*(handle: VkRenderPass): bool = uint(handle) != 0
225 proc Reset*(handle: var VkRenderPass) = handle = VkRenderPass(0)
226 proc `==`*(a, b: VkRenderPass): bool = uint(a) == uint(b)
227 proc `$`*(handle: VkPipelineCache): string = "VkPipelineCache(" & $(uint(handle)) & ")"
228 proc Valid*(handle: VkPipelineCache): bool = uint(handle) != 0
229 proc Reset*(handle: var VkPipelineCache) = handle = VkPipelineCache(0)
230 proc `==`*(a, b: VkPipelineCache): bool = uint(a) == uint(b)
231 proc `$`*(handle: VkIndirectCommandsLayoutNV): string = "VkIndirectCommandsLayoutNV(" & $(uint(handle)) & ")"
232 proc Valid*(handle: VkIndirectCommandsLayoutNV): bool = uint(handle) != 0
233 proc Reset*(handle: var VkIndirectCommandsLayoutNV) = handle = VkIndirectCommandsLayoutNV(0)
234 proc `==`*(a, b: VkIndirectCommandsLayoutNV): bool = uint(a) == uint(b)
235 proc `$`*(handle: VkDescriptorUpdateTemplate): string = "VkDescriptorUpdateTemplate(" & $(uint(handle)) & ")"
236 proc Valid*(handle: VkDescriptorUpdateTemplate): bool = uint(handle) != 0
237 proc Reset*(handle: var VkDescriptorUpdateTemplate) = handle = VkDescriptorUpdateTemplate(0)
238 proc `==`*(a, b: VkDescriptorUpdateTemplate): bool = uint(a) == uint(b)
239 proc `$`*(handle: VkSamplerYcbcrConversion): string = "VkSamplerYcbcrConversion(" & $(uint(handle)) & ")"
240 proc Valid*(handle: VkSamplerYcbcrConversion): bool = uint(handle) != 0
241 proc Reset*(handle: var VkSamplerYcbcrConversion) = handle = VkSamplerYcbcrConversion(0)
242 proc `==`*(a, b: VkSamplerYcbcrConversion): bool = uint(a) == uint(b)
243 proc `$`*(handle: VkValidationCacheEXT): string = "VkValidationCacheEXT(" & $(uint(handle)) & ")"
244 proc Valid*(handle: VkValidationCacheEXT): bool = uint(handle) != 0
245 proc Reset*(handle: var VkValidationCacheEXT) = handle = VkValidationCacheEXT(0)
246 proc `==`*(a, b: VkValidationCacheEXT): bool = uint(a) == uint(b)
247 proc `$`*(handle: VkAccelerationStructureKHR): string = "VkAccelerationStructureKHR(" & $(uint(handle)) & ")"
248 proc Valid*(handle: VkAccelerationStructureKHR): bool = uint(handle) != 0
249 proc Reset*(handle: var VkAccelerationStructureKHR) = handle = VkAccelerationStructureKHR(0)
250 proc `==`*(a, b: VkAccelerationStructureKHR): bool = uint(a) == uint(b)
251 proc `$`*(handle: VkAccelerationStructureNV): string = "VkAccelerationStructureNV(" & $(uint(handle)) & ")"
252 proc Valid*(handle: VkAccelerationStructureNV): bool = uint(handle) != 0
253 proc Reset*(handle: var VkAccelerationStructureNV) = handle = VkAccelerationStructureNV(0)
254 proc `==`*(a, b: VkAccelerationStructureNV): bool = uint(a) == uint(b)
255 proc `$`*(handle: VkPerformanceConfigurationINTEL): string = "VkPerformanceConfigurationINTEL(" & $(uint(handle)) & ")"
256 proc Valid*(handle: VkPerformanceConfigurationINTEL): bool = uint(handle) != 0
257 proc Reset*(handle: var VkPerformanceConfigurationINTEL) = handle = VkPerformanceConfigurationINTEL(0)
258 proc `==`*(a, b: VkPerformanceConfigurationINTEL): bool = uint(a) == uint(b)
259 proc `$`*(handle: VkBufferCollectionFUCHSIA): string = "VkBufferCollectionFUCHSIA(" & $(uint(handle)) & ")"
260 proc Valid*(handle: VkBufferCollectionFUCHSIA): bool = uint(handle) != 0
261 proc Reset*(handle: var VkBufferCollectionFUCHSIA) = handle = VkBufferCollectionFUCHSIA(0)
262 proc `==`*(a, b: VkBufferCollectionFUCHSIA): bool = uint(a) == uint(b)
263 proc `$`*(handle: VkDeferredOperationKHR): string = "VkDeferredOperationKHR(" & $(uint(handle)) & ")"
264 proc Valid*(handle: VkDeferredOperationKHR): bool = uint(handle) != 0
265 proc Reset*(handle: var VkDeferredOperationKHR) = handle = VkDeferredOperationKHR(0)
266 proc `==`*(a, b: VkDeferredOperationKHR): bool = uint(a) == uint(b)
267 proc `$`*(handle: VkPrivateDataSlot): string = "VkPrivateDataSlot(" & $(uint(handle)) & ")"
268 proc Valid*(handle: VkPrivateDataSlot): bool = uint(handle) != 0
269 proc Reset*(handle: var VkPrivateDataSlot) = handle = VkPrivateDataSlot(0)
270 proc `==`*(a, b: VkPrivateDataSlot): bool = uint(a) == uint(b)
271 proc `$`*(handle: VkCuModuleNVX): string = "VkCuModuleNVX(" & $(uint(handle)) & ")"
272 proc Valid*(handle: VkCuModuleNVX): bool = uint(handle) != 0
273 proc Reset*(handle: var VkCuModuleNVX) = handle = VkCuModuleNVX(0)
274 proc `==`*(a, b: VkCuModuleNVX): bool = uint(a) == uint(b)
275 proc `$`*(handle: VkCuFunctionNVX): string = "VkCuFunctionNVX(" & $(uint(handle)) & ")"
276 proc Valid*(handle: VkCuFunctionNVX): bool = uint(handle) != 0
277 proc Reset*(handle: var VkCuFunctionNVX) = handle = VkCuFunctionNVX(0)
278 proc `==`*(a, b: VkCuFunctionNVX): bool = uint(a) == uint(b)
279 proc `$`*(handle: VkOpticalFlowSessionNV): string = "VkOpticalFlowSessionNV(" & $(uint(handle)) & ")"
280 proc Valid*(handle: VkOpticalFlowSessionNV): bool = uint(handle) != 0
281 proc Reset*(handle: var VkOpticalFlowSessionNV) = handle = VkOpticalFlowSessionNV(0)
282 proc `==`*(a, b: VkOpticalFlowSessionNV): bool = uint(a) == uint(b)
283 proc `$`*(handle: VkMicromapEXT): string = "VkMicromapEXT(" & $(uint(handle)) & ")"
284 proc Valid*(handle: VkMicromapEXT): bool = uint(handle) != 0
285 proc Reset*(handle: var VkMicromapEXT) = handle = VkMicromapEXT(0)
286 proc `==`*(a, b: VkMicromapEXT): bool = uint(a) == uint(b)
287 proc `$`*(handle: VkDisplayKHR): string = "VkDisplayKHR(" & $(uint(handle)) & ")"
288 proc Valid*(handle: VkDisplayKHR): bool = uint(handle) != 0
289 proc Reset*(handle: var VkDisplayKHR) = handle = VkDisplayKHR(0)
290 proc `==`*(a, b: VkDisplayKHR): bool = uint(a) == uint(b)
291 proc `$`*(handle: VkDisplayModeKHR): string = "VkDisplayModeKHR(" & $(uint(handle)) & ")"
292 proc Valid*(handle: VkDisplayModeKHR): bool = uint(handle) != 0
293 proc Reset*(handle: var VkDisplayModeKHR) = handle = VkDisplayModeKHR(0)
294 proc `==`*(a, b: VkDisplayModeKHR): bool = uint(a) == uint(b)
295 proc `$`*(handle: VkSurfaceKHR): string = "VkSurfaceKHR(" & $(uint(handle)) & ")"
296 proc Valid*(handle: VkSurfaceKHR): bool = uint(handle) != 0
297 proc Reset*(handle: var VkSurfaceKHR) = handle = VkSurfaceKHR(0)
298 proc `==`*(a, b: VkSurfaceKHR): bool = uint(a) == uint(b)
299 proc `$`*(handle: VkSwapchainKHR): string = "VkSwapchainKHR(" & $(uint(handle)) & ")"
300 proc Valid*(handle: VkSwapchainKHR): bool = uint(handle) != 0
301 proc Reset*(handle: var VkSwapchainKHR) = handle = VkSwapchainKHR(0)
302 proc `==`*(a, b: VkSwapchainKHR): bool = uint(a) == uint(b)
303 proc `$`*(handle: VkDebugReportCallbackEXT): string = "VkDebugReportCallbackEXT(" & $(uint(handle)) & ")"
304 proc Valid*(handle: VkDebugReportCallbackEXT): bool = uint(handle) != 0
305 proc Reset*(handle: var VkDebugReportCallbackEXT) = handle = VkDebugReportCallbackEXT(0)
306 proc `==`*(a, b: VkDebugReportCallbackEXT): bool = uint(a) == uint(b)
307 proc `$`*(handle: VkDebugUtilsMessengerEXT): string = "VkDebugUtilsMessengerEXT(" & $(uint(handle)) & ")"
308 proc Valid*(handle: VkDebugUtilsMessengerEXT): bool = uint(handle) != 0
309 proc Reset*(handle: var VkDebugUtilsMessengerEXT) = handle = VkDebugUtilsMessengerEXT(0)
310 proc `==`*(a, b: VkDebugUtilsMessengerEXT): bool = uint(a) == uint(b)
311 proc `$`*(handle: VkVideoSessionKHR): string = "VkVideoSessionKHR(" & $(uint(handle)) & ")"
312 proc Valid*(handle: VkVideoSessionKHR): bool = uint(handle) != 0
313 proc Reset*(handle: var VkVideoSessionKHR) = handle = VkVideoSessionKHR(0)
314 proc `==`*(a, b: VkVideoSessionKHR): bool = uint(a) == uint(b)
315 proc `$`*(handle: VkVideoSessionParametersKHR): string = "VkVideoSessionParametersKHR(" & $(uint(handle)) & ")"
316 proc Valid*(handle: VkVideoSessionParametersKHR): bool = uint(handle) != 0
317 proc Reset*(handle: var VkVideoSessionParametersKHR) = handle = VkVideoSessionParametersKHR(0)
318 proc `==`*(a, b: VkVideoSessionParametersKHR): bool = uint(a) == uint(b)
319 proc `$`*(handle: VkSemaphoreSciSyncPoolNV): string = "VkSemaphoreSciSyncPoolNV(" & $(uint(handle)) & ")"
320 proc Valid*(handle: VkSemaphoreSciSyncPoolNV): bool = uint(handle) != 0
321 proc Reset*(handle: var VkSemaphoreSciSyncPoolNV) = handle = VkSemaphoreSciSyncPoolNV(0)
322 proc `==`*(a, b: VkSemaphoreSciSyncPoolNV): bool = uint(a) == uint(b)
323 type
324 VkFramebufferCreateFlags* = distinct VkFlags
325 VkQueryPoolCreateFlags* = distinct VkFlags
326 VkRenderPassCreateFlags* = distinct VkFlags
327 VkSamplerCreateFlags* = distinct VkFlags
328 VkPipelineLayoutCreateFlags* = distinct VkFlags
329 VkPipelineCacheCreateFlags* = distinct VkFlags
330 VkPipelineDepthStencilStateCreateFlags* = distinct VkFlags
331 VkPipelineDynamicStateCreateFlags* = distinct VkFlags
332 VkPipelineColorBlendStateCreateFlags* = distinct VkFlags
333 VkPipelineMultisampleStateCreateFlags* = distinct VkFlags
334 VkPipelineRasterizationStateCreateFlags* = distinct VkFlags
335 VkPipelineViewportStateCreateFlags* = distinct VkFlags
336 VkPipelineTessellationStateCreateFlags* = distinct VkFlags
337 VkPipelineInputAssemblyStateCreateFlags* = distinct VkFlags
338 VkPipelineVertexInputStateCreateFlags* = distinct VkFlags
339 VkPipelineShaderStageCreateFlags* = distinct VkFlags
340 VkDescriptorSetLayoutCreateFlags* = distinct VkFlags
341 VkBufferViewCreateFlags* = distinct VkFlags
342 VkInstanceCreateFlags* = distinct VkFlags
343 VkDeviceCreateFlags* = distinct VkFlags
344 VkDeviceQueueCreateFlags* = distinct VkFlags
345 VkQueueFlags* = distinct VkFlags
346 VkMemoryPropertyFlags* = distinct VkFlags
347 VkMemoryHeapFlags* = distinct VkFlags
348 VkAccessFlags* = distinct VkFlags
349 VkBufferUsageFlags* = distinct VkFlags
350 VkBufferCreateFlags* = distinct VkFlags
351 VkShaderStageFlags* = distinct VkFlags
352 VkImageUsageFlags* = distinct VkFlags
353 VkImageCreateFlags* = distinct VkFlags
354 VkImageViewCreateFlags* = distinct VkFlags
355 VkPipelineCreateFlags* = distinct VkFlags
356 VkColorComponentFlags* = distinct VkFlags
357 VkFenceCreateFlags* = distinct VkFlags
358 VkSemaphoreCreateFlags* = distinct VkFlags
359 VkFormatFeatureFlags* = distinct VkFlags
360 VkQueryControlFlags* = distinct VkFlags
361 VkQueryResultFlags* = distinct VkFlags
362 VkShaderModuleCreateFlags* = distinct VkFlags
363 VkEventCreateFlags* = distinct VkFlags
364 VkCommandPoolCreateFlags* = distinct VkFlags
365 VkCommandPoolResetFlags* = distinct VkFlags
366 VkCommandBufferResetFlags* = distinct VkFlags
367 VkCommandBufferUsageFlags* = distinct VkFlags
368 VkQueryPipelineStatisticFlags* = distinct VkFlags
369 VkMemoryMapFlags* = distinct VkFlags
370 VkImageAspectFlags* = distinct VkFlags
371 VkSparseMemoryBindFlags* = distinct VkFlags
372 VkSparseImageFormatFlags* = distinct VkFlags
373 VkSubpassDescriptionFlags* = distinct VkFlags
374 VkPipelineStageFlags* = distinct VkFlags
375 VkSampleCountFlags* = distinct VkFlags
376 VkAttachmentDescriptionFlags* = distinct VkFlags
377 VkStencilFaceFlags* = distinct VkFlags
378 VkCullModeFlags* = distinct VkFlags
379 VkDescriptorPoolCreateFlags* = distinct VkFlags
380 VkDescriptorPoolResetFlags* = distinct VkFlags
381 VkDependencyFlags* = distinct VkFlags
382 VkSubgroupFeatureFlags* = distinct VkFlags
383 VkIndirectCommandsLayoutUsageFlagsNV* = distinct VkFlags
384 VkIndirectStateFlagsNV* = distinct VkFlags
385 VkGeometryFlagsKHR* = distinct VkFlags
386 VkGeometryInstanceFlagsKHR* = distinct VkFlags
387 VkBuildAccelerationStructureFlagsKHR* = distinct VkFlags
388 VkPrivateDataSlotCreateFlags* = distinct VkFlags
389 VkAccelerationStructureCreateFlagsKHR* = distinct VkFlags
390 VkDescriptorUpdateTemplateCreateFlags* = distinct VkFlags
391 VkPipelineCreationFeedbackFlags* = distinct VkFlags
392 VkPerformanceCounterDescriptionFlagsKHR* = distinct VkFlags
393 VkAcquireProfilingLockFlagsKHR* = distinct VkFlags
394 VkSemaphoreWaitFlags* = distinct VkFlags
395 VkPipelineCompilerControlFlagsAMD* = distinct VkFlags
396 VkShaderCorePropertiesFlagsAMD* = distinct VkFlags
397 VkDeviceDiagnosticsConfigFlagsNV* = distinct VkFlags
398 VkRefreshObjectFlagsKHR* = distinct VkFlags
399 VkAccessFlags2* = distinct VkFlags64
400 VkPipelineStageFlags2* = distinct VkFlags64
401 VkAccelerationStructureMotionInfoFlagsNV* = distinct VkFlags
402 VkAccelerationStructureMotionInstanceFlagsNV* = distinct VkFlags
403 VkFormatFeatureFlags2* = distinct VkFlags64
404 VkRenderingFlags* = distinct VkFlags
405 VkMemoryDecompressionMethodFlagsNV* = distinct VkFlags64
406 VkBuildMicromapFlagsEXT* = distinct VkFlags
407 VkMicromapCreateFlagsEXT* = distinct VkFlags
408 VkDirectDriverLoadingFlagsLUNARG* = distinct VkFlags
409 VkCompositeAlphaFlagsKHR* = distinct VkFlags
410 VkDisplayPlaneAlphaFlagsKHR* = distinct VkFlags
411 VkSurfaceTransformFlagsKHR* = distinct VkFlags
412 VkSwapchainCreateFlagsKHR* = distinct VkFlags
413 VkDisplayModeCreateFlagsKHR* = distinct VkFlags
414 VkDisplaySurfaceCreateFlagsKHR* = distinct VkFlags
415 VkAndroidSurfaceCreateFlagsKHR* = distinct VkFlags
416 VkViSurfaceCreateFlagsNN* = distinct VkFlags
417 VkWaylandSurfaceCreateFlagsKHR* = distinct VkFlags
418 VkWin32SurfaceCreateFlagsKHR* = distinct VkFlags
419 VkXlibSurfaceCreateFlagsKHR* = distinct VkFlags
420 VkXcbSurfaceCreateFlagsKHR* = distinct VkFlags
421 VkDirectFBSurfaceCreateFlagsEXT* = distinct VkFlags
422 VkIOSSurfaceCreateFlagsMVK* = distinct VkFlags
423 VkMacOSSurfaceCreateFlagsMVK* = distinct VkFlags
424 VkMetalSurfaceCreateFlagsEXT* = distinct VkFlags
425 VkImagePipeSurfaceCreateFlagsFUCHSIA* = distinct VkFlags
426 VkStreamDescriptorSurfaceCreateFlagsGGP* = distinct VkFlags
427 VkHeadlessSurfaceCreateFlagsEXT* = distinct VkFlags
428 VkScreenSurfaceCreateFlagsQNX* = distinct VkFlags
429 VkPeerMemoryFeatureFlags* = distinct VkFlags
430 VkMemoryAllocateFlags* = distinct VkFlags
431 VkDeviceGroupPresentModeFlagsKHR* = distinct VkFlags
432 VkDebugReportFlagsEXT* = distinct VkFlags
433 VkCommandPoolTrimFlags* = distinct VkFlags
434 VkExternalMemoryHandleTypeFlagsNV* = distinct VkFlags
435 VkExternalMemoryFeatureFlagsNV* = distinct VkFlags
436 VkExternalMemoryHandleTypeFlags* = distinct VkFlags
437 VkExternalMemoryFeatureFlags* = distinct VkFlags
438 VkExternalSemaphoreHandleTypeFlags* = distinct VkFlags
439 VkExternalSemaphoreFeatureFlags* = distinct VkFlags
440 VkSemaphoreImportFlags* = distinct VkFlags
441 VkExternalFenceHandleTypeFlags* = distinct VkFlags
442 VkExternalFenceFeatureFlags* = distinct VkFlags
443 VkFenceImportFlags* = distinct VkFlags
444 VkSurfaceCounterFlagsEXT* = distinct VkFlags
445 VkPipelineViewportSwizzleStateCreateFlagsNV* = distinct VkFlags
446 VkPipelineDiscardRectangleStateCreateFlagsEXT* = distinct VkFlags
447 VkPipelineCoverageToColorStateCreateFlagsNV* = distinct VkFlags
448 VkPipelineCoverageModulationStateCreateFlagsNV* = distinct VkFlags
449 VkPipelineCoverageReductionStateCreateFlagsNV* = distinct VkFlags
450 VkValidationCacheCreateFlagsEXT* = distinct VkFlags
451 VkDebugUtilsMessageSeverityFlagsEXT* = distinct VkFlags
452 VkDebugUtilsMessageTypeFlagsEXT* = distinct VkFlags
453 VkDebugUtilsMessengerCreateFlagsEXT* = distinct VkFlags
454 VkDebugUtilsMessengerCallbackDataFlagsEXT* = distinct VkFlags
455 VkDeviceMemoryReportFlagsEXT* = distinct VkFlags
456 VkPipelineRasterizationConservativeStateCreateFlagsEXT* = distinct VkFlags
457 VkDescriptorBindingFlags* = distinct VkFlags
458 VkConditionalRenderingFlagsEXT* = distinct VkFlags
459 VkResolveModeFlags* = distinct VkFlags
460 VkPipelineRasterizationStateStreamCreateFlagsEXT* = distinct VkFlags
461 VkPipelineRasterizationDepthClipStateCreateFlagsEXT* = distinct VkFlags
462 VkSwapchainImageUsageFlagsANDROID* = distinct VkFlags
463 VkToolPurposeFlags* = distinct VkFlags
464 VkSubmitFlags* = distinct VkFlags
465 VkImageFormatConstraintsFlagsFUCHSIA* = distinct VkFlags
466 VkImageConstraintsInfoFlagsFUCHSIA* = distinct VkFlags
467 VkGraphicsPipelineLibraryFlagsEXT* = distinct VkFlags
468 VkImageCompressionFlagsEXT* = distinct VkFlags
469 VkImageCompressionFixedRateFlagsEXT* = distinct VkFlags
470 VkExportMetalObjectTypeFlagsEXT* = distinct VkFlags
471 VkDeviceAddressBindingFlagsEXT* = distinct VkFlags
472 VkOpticalFlowGridSizeFlagsNV* = distinct VkFlags
473 VkOpticalFlowUsageFlagsNV* = distinct VkFlags
474 VkOpticalFlowSessionCreateFlagsNV* = distinct VkFlags
475 VkOpticalFlowExecuteFlagsNV* = distinct VkFlags
476 VkPresentScalingFlagsEXT* = distinct VkFlags
477 VkPresentGravityFlagsEXT* = distinct VkFlags
478 VkVideoCodecOperationFlagsKHR* = distinct VkFlags
479 VkVideoCapabilityFlagsKHR* = distinct VkFlags
480 VkVideoSessionCreateFlagsKHR* = distinct VkFlags
481 VkVideoSessionParametersCreateFlagsKHR* = distinct VkFlags
482 VkVideoBeginCodingFlagsKHR* = distinct VkFlags
483 VkVideoEndCodingFlagsKHR* = distinct VkFlags
484 VkVideoCodingControlFlagsKHR* = distinct VkFlags
485 VkVideoDecodeUsageFlagsKHR* = distinct VkFlags
486 VkVideoDecodeCapabilityFlagsKHR* = distinct VkFlags
487 VkVideoDecodeFlagsKHR* = distinct VkFlags
488 VkVideoDecodeH264PictureLayoutFlagsKHR* = distinct VkFlags
489 VkVideoEncodeFlagsKHR* = distinct VkFlags
490 VkVideoEncodeUsageFlagsKHR* = distinct VkFlags
491 VkVideoEncodeContentFlagsKHR* = distinct VkFlags
492 VkVideoEncodeCapabilityFlagsKHR* = distinct VkFlags
493 VkVideoEncodeRateControlFlagsKHR* = distinct VkFlags
494 VkVideoEncodeRateControlModeFlagsKHR* = distinct VkFlags
495 VkVideoChromaSubsamplingFlagsKHR* = distinct VkFlags
496 VkVideoComponentBitDepthFlagsKHR* = distinct VkFlags
497 VkVideoEncodeH264CapabilityFlagsEXT* = distinct VkFlags
498 VkVideoEncodeH264InputModeFlagsEXT* = distinct VkFlags
499 VkVideoEncodeH264OutputModeFlagsEXT* = distinct VkFlags
500 VkVideoEncodeH265CapabilityFlagsEXT* = distinct VkFlags
501 VkVideoEncodeH265InputModeFlagsEXT* = distinct VkFlags
502 VkVideoEncodeH265OutputModeFlagsEXT* = distinct VkFlags
503 VkVideoEncodeH265CtbSizeFlagsEXT* = distinct VkFlags
504 VkVideoEncodeH265TransformBlockSizeFlagsEXT* = distinct VkFlags
505 let vkGetInstanceProcAddr = cast[proc(instance: VkInstance, name: cstring): pointer {.stdcall.}](checkedSymAddr(vulkanLib, "vkGetInstanceProcAddr"))
506 type
507 VkImageLayout* {.size: sizeof(cint).} = enum
508 VK_IMAGE_LAYOUT_UNDEFINED = 0
509 VK_IMAGE_LAYOUT_GENERAL = 1
510 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2
511 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3
512 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4
513 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5
514 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6
515 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7
516 VK_IMAGE_LAYOUT_PREINITIALIZED = 8
517 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002
518 VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000
519 VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001
520 VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002
521 VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000
522 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000
523 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001
524 VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003
525 VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000
526 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000
527 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001
528 VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002
529 VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003
530 VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000
531 VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001
532 VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002
533 VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000
534 VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001
535 VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000
536 VkAttachmentLoadOp* {.size: sizeof(cint).} = enum
537 VK_ATTACHMENT_LOAD_OP_LOAD = 0
538 VK_ATTACHMENT_LOAD_OP_CLEAR = 1
539 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
540 VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000
541 VkAttachmentStoreOp* {.size: sizeof(cint).} = enum
542 VK_ATTACHMENT_STORE_OP_STORE = 0
543 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
544 VK_ATTACHMENT_STORE_OP_NONE = 1000301000
545 VkImageType* {.size: sizeof(cint).} = enum
546 VK_IMAGE_TYPE_1D = 0
547 VK_IMAGE_TYPE_2D = 1
548 VK_IMAGE_TYPE_3D = 2
549 VkImageTiling* {.size: sizeof(cint).} = enum
550 VK_IMAGE_TILING_OPTIMAL = 0
551 VK_IMAGE_TILING_LINEAR = 1
552 VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000
553 VkImageViewType* {.size: sizeof(cint).} = enum
554 VK_IMAGE_VIEW_TYPE_1D = 0
555 VK_IMAGE_VIEW_TYPE_2D = 1
556 VK_IMAGE_VIEW_TYPE_3D = 2
557 VK_IMAGE_VIEW_TYPE_CUBE = 3
558 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4
559 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5
560 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6
561 VkCommandBufferLevel* {.size: sizeof(cint).} = enum
562 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0
563 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
564 VkComponentSwizzle* {.size: sizeof(cint).} = enum
565 VK_COMPONENT_SWIZZLE_IDENTITY = 0
566 VK_COMPONENT_SWIZZLE_ZERO = 1
567 VK_COMPONENT_SWIZZLE_ONE = 2
568 VK_COMPONENT_SWIZZLE_R = 3
569 VK_COMPONENT_SWIZZLE_G = 4
570 VK_COMPONENT_SWIZZLE_B = 5
571 VK_COMPONENT_SWIZZLE_A = 6
572 VkDescriptorType* {.size: sizeof(cint).} = enum
573 VK_DESCRIPTOR_TYPE_SAMPLER = 0
574 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1
575 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2
576 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3
577 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4
578 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5
579 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6
580 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7
581 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8
582 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9
583 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10
584 VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000
585 VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000
586 VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000
587 VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000
588 VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000
589 VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001
590 VkQueryType* {.size: sizeof(cint).} = enum
591 VK_QUERY_TYPE_OCCLUSION = 0
592 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1
593 VK_QUERY_TYPE_TIMESTAMP = 2
594 VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000
595 VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004
596 VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000
597 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000
598 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001
599 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000
600 VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000
601 VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000
602 VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000
603 VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000
604 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000
605 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001
606 VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000
607 VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001
608 VkBorderColor* {.size: sizeof(cint).} = enum
609 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0
610 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1
611 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2
612 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3
613 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4
614 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5
615 VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003
616 VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004
617 VkPipelineBindPoint* {.size: sizeof(cint).} = enum
618 VK_PIPELINE_BIND_POINT_GRAPHICS = 0
619 VK_PIPELINE_BIND_POINT_COMPUTE = 1
620 VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000
621 VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003
622 VkPipelineCacheHeaderVersion* {.size: sizeof(cint).} = enum
623 VK_PIPELINE_CACHE_HEADER_VERSION_ONE_ENUM = 1
624 VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE_ENUM = 1000298001
625 VkPipelineCacheCreateFlagBits* {.size: sizeof(cint).} = enum
626 VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0b00000000000000000000000000000001
627 VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT = 0b00000000000000000000000000000010
628 VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT = 0b00000000000000000000000000000100
629 func toBits*(flags: openArray[VkPipelineCacheCreateFlagBits]): VkPipelineCacheCreateFlags =
630 for flag in flags:
631 result = VkPipelineCacheCreateFlags(uint(result) or uint(flag))
632 func toEnums*(number: VkPipelineCacheCreateFlags): seq[VkPipelineCacheCreateFlagBits] =
633 for value in VkPipelineCacheCreateFlagBits.items:
634 if (value.ord and cint(number)) > 0:
635 result.add value
636 proc `==`*(a, b: VkPipelineCacheCreateFlags): bool = cint(a) == cint(b)
637 type
638 VkPrimitiveTopology* {.size: sizeof(cint).} = enum
639 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0
640 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1
641 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2
642 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3
643 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4
644 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5
645 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6
646 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7
647 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8
648 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9
649 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10
650 VkSharingMode* {.size: sizeof(cint).} = enum
651 VK_SHARING_MODE_EXCLUSIVE = 0
652 VK_SHARING_MODE_CONCURRENT = 1
653 VkIndexType* {.size: sizeof(cint).} = enum
654 VK_INDEX_TYPE_UINT16 = 0
655 VK_INDEX_TYPE_UINT32 = 1
656 VK_INDEX_TYPE_NONE_KHR = 1000165000
657 VK_INDEX_TYPE_UINT8_EXT = 1000265000
658 VkFilter* {.size: sizeof(cint).} = enum
659 VK_FILTER_NEAREST = 0
660 VK_FILTER_LINEAR = 1
661 VK_FILTER_CUBIC_EXT = 1000015000
662 VkSamplerMipmapMode* {.size: sizeof(cint).} = enum
663 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0
664 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
665 VkSamplerAddressMode* {.size: sizeof(cint).} = enum
666 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0
667 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1
668 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2
669 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3
670 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4
671 VkCompareOp* {.size: sizeof(cint).} = enum
672 VK_COMPARE_OP_NEVER = 0
673 VK_COMPARE_OP_LESS = 1
674 VK_COMPARE_OP_EQUAL = 2
675 VK_COMPARE_OP_LESS_OR_EQUAL = 3
676 VK_COMPARE_OP_GREATER = 4
677 VK_COMPARE_OP_NOT_EQUAL = 5
678 VK_COMPARE_OP_GREATER_OR_EQUAL = 6
679 VK_COMPARE_OP_ALWAYS = 7
680 VkPolygonMode* {.size: sizeof(cint).} = enum
681 VK_POLYGON_MODE_FILL = 0
682 VK_POLYGON_MODE_LINE = 1
683 VK_POLYGON_MODE_POINT = 2
684 VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000
685 VkFrontFace* {.size: sizeof(cint).} = enum
686 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0
687 VK_FRONT_FACE_CLOCKWISE = 1
688 VkBlendFactor* {.size: sizeof(cint).} = enum
689 VK_BLEND_FACTOR_ZERO = 0
690 VK_BLEND_FACTOR_ONE = 1
691 VK_BLEND_FACTOR_SRC_COLOR = 2
692 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3
693 VK_BLEND_FACTOR_DST_COLOR = 4
694 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5
695 VK_BLEND_FACTOR_SRC_ALPHA = 6
696 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7
697 VK_BLEND_FACTOR_DST_ALPHA = 8
698 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9
699 VK_BLEND_FACTOR_CONSTANT_COLOR = 10
700 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11
701 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12
702 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13
703 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14
704 VK_BLEND_FACTOR_SRC1_COLOR = 15
705 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16
706 VK_BLEND_FACTOR_SRC1_ALPHA = 17
707 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18
708 VkBlendOp* {.size: sizeof(cint).} = enum
709 VK_BLEND_OP_ADD = 0
710 VK_BLEND_OP_SUBTRACT = 1
711 VK_BLEND_OP_REVERSE_SUBTRACT = 2
712 VK_BLEND_OP_MIN = 3
713 VK_BLEND_OP_MAX = 4
714 VK_BLEND_OP_ZERO_EXT = 1000148000
715 VK_BLEND_OP_SRC_EXT = 1000148001
716 VK_BLEND_OP_DST_EXT = 1000148002
717 VK_BLEND_OP_SRC_OVER_EXT = 1000148003
718 VK_BLEND_OP_DST_OVER_EXT = 1000148004
719 VK_BLEND_OP_SRC_IN_EXT = 1000148005
720 VK_BLEND_OP_DST_IN_EXT = 1000148006
721 VK_BLEND_OP_SRC_OUT_EXT = 1000148007
722 VK_BLEND_OP_DST_OUT_EXT = 1000148008
723 VK_BLEND_OP_SRC_ATOP_EXT = 1000148009
724 VK_BLEND_OP_DST_ATOP_EXT = 1000148010
725 VK_BLEND_OP_XOR_EXT = 1000148011
726 VK_BLEND_OP_MULTIPLY_EXT = 1000148012
727 VK_BLEND_OP_SCREEN_EXT = 1000148013
728 VK_BLEND_OP_OVERLAY_EXT = 1000148014
729 VK_BLEND_OP_DARKEN_EXT = 1000148015
730 VK_BLEND_OP_LIGHTEN_EXT = 1000148016
731 VK_BLEND_OP_COLORDODGE_EXT = 1000148017
732 VK_BLEND_OP_COLORBURN_EXT = 1000148018
733 VK_BLEND_OP_HARDLIGHT_EXT = 1000148019
734 VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020
735 VK_BLEND_OP_DIFFERENCE_EXT = 1000148021
736 VK_BLEND_OP_EXCLUSION_EXT = 1000148022
737 VK_BLEND_OP_INVERT_EXT = 1000148023
738 VK_BLEND_OP_INVERT_RGB_EXT = 1000148024
739 VK_BLEND_OP_LINEARDODGE_EXT = 1000148025
740 VK_BLEND_OP_LINEARBURN_EXT = 1000148026
741 VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027
742 VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028
743 VK_BLEND_OP_PINLIGHT_EXT = 1000148029
744 VK_BLEND_OP_HARDMIX_EXT = 1000148030
745 VK_BLEND_OP_HSL_HUE_EXT = 1000148031
746 VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032
747 VK_BLEND_OP_HSL_COLOR_EXT = 1000148033
748 VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034
749 VK_BLEND_OP_PLUS_EXT = 1000148035
750 VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036
751 VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037
752 VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038
753 VK_BLEND_OP_MINUS_EXT = 1000148039
754 VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040
755 VK_BLEND_OP_CONTRAST_EXT = 1000148041
756 VK_BLEND_OP_INVERT_OVG_EXT = 1000148042
757 VK_BLEND_OP_RED_EXT = 1000148043
758 VK_BLEND_OP_GREEN_EXT = 1000148044
759 VK_BLEND_OP_BLUE_EXT = 1000148045
760 VkStencilOp* {.size: sizeof(cint).} = enum
761 VK_STENCIL_OP_KEEP = 0
762 VK_STENCIL_OP_ZERO = 1
763 VK_STENCIL_OP_REPLACE = 2
764 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3
765 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4
766 VK_STENCIL_OP_INVERT = 5
767 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6
768 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7
769 VkLogicOp* {.size: sizeof(cint).} = enum
770 VK_LOGIC_OP_CLEAR = 0
771 VK_LOGIC_OP_AND = 1
772 VK_LOGIC_OP_AND_REVERSE = 2
773 VK_LOGIC_OP_COPY = 3
774 VK_LOGIC_OP_AND_INVERTED = 4
775 VK_LOGIC_OP_NO_OP = 5
776 VK_LOGIC_OP_XOR = 6
777 VK_LOGIC_OP_OR = 7
778 VK_LOGIC_OP_NOR = 8
779 VK_LOGIC_OP_EQUIVALENT = 9
780 VK_LOGIC_OP_INVERT = 10
781 VK_LOGIC_OP_OR_REVERSE = 11
782 VK_LOGIC_OP_COPY_INVERTED = 12
783 VK_LOGIC_OP_OR_INVERTED = 13
784 VK_LOGIC_OP_NAND = 14
785 VK_LOGIC_OP_SET = 15
786 VkInternalAllocationType* {.size: sizeof(cint).} = enum
787 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
788 VkSystemAllocationScope* {.size: sizeof(cint).} = enum
789 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0
790 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1
791 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2
792 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3
793 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4
794 VkPhysicalDeviceType* {.size: sizeof(cint).} = enum
795 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0
796 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1
797 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2
798 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3
799 VK_PHYSICAL_DEVICE_TYPE_CPU = 4
800 VkVertexInputRate* {.size: sizeof(cint).} = enum
801 VK_VERTEX_INPUT_RATE_VERTEX = 0
802 VK_VERTEX_INPUT_RATE_INSTANCE = 1
803 VkFormat* {.size: sizeof(cint).} = enum
804 VK_FORMAT_UNDEFINED = 0
805 VK_FORMAT_R4G4_UNORM_PACK8 = 1
806 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2
807 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3
808 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4
809 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5
810 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6
811 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7
812 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8
813 VK_FORMAT_R8_UNORM = 9
814 VK_FORMAT_R8_SNORM = 10
815 VK_FORMAT_R8_USCALED = 11
816 VK_FORMAT_R8_SSCALED = 12
817 VK_FORMAT_R8_UINT = 13
818 VK_FORMAT_R8_SINT = 14
819 VK_FORMAT_R8_SRGB = 15
820 VK_FORMAT_R8G8_UNORM = 16
821 VK_FORMAT_R8G8_SNORM = 17
822 VK_FORMAT_R8G8_USCALED = 18
823 VK_FORMAT_R8G8_SSCALED = 19
824 VK_FORMAT_R8G8_UINT = 20
825 VK_FORMAT_R8G8_SINT = 21
826 VK_FORMAT_R8G8_SRGB = 22
827 VK_FORMAT_R8G8B8_UNORM = 23
828 VK_FORMAT_R8G8B8_SNORM = 24
829 VK_FORMAT_R8G8B8_USCALED = 25
830 VK_FORMAT_R8G8B8_SSCALED = 26
831 VK_FORMAT_R8G8B8_UINT = 27
832 VK_FORMAT_R8G8B8_SINT = 28
833 VK_FORMAT_R8G8B8_SRGB = 29
834 VK_FORMAT_B8G8R8_UNORM = 30
835 VK_FORMAT_B8G8R8_SNORM = 31
836 VK_FORMAT_B8G8R8_USCALED = 32
837 VK_FORMAT_B8G8R8_SSCALED = 33
838 VK_FORMAT_B8G8R8_UINT = 34
839 VK_FORMAT_B8G8R8_SINT = 35
840 VK_FORMAT_B8G8R8_SRGB = 36
841 VK_FORMAT_R8G8B8A8_UNORM = 37
842 VK_FORMAT_R8G8B8A8_SNORM = 38
843 VK_FORMAT_R8G8B8A8_USCALED = 39
844 VK_FORMAT_R8G8B8A8_SSCALED = 40
845 VK_FORMAT_R8G8B8A8_UINT = 41
846 VK_FORMAT_R8G8B8A8_SINT = 42
847 VK_FORMAT_R8G8B8A8_SRGB = 43
848 VK_FORMAT_B8G8R8A8_UNORM = 44
849 VK_FORMAT_B8G8R8A8_SNORM = 45
850 VK_FORMAT_B8G8R8A8_USCALED = 46
851 VK_FORMAT_B8G8R8A8_SSCALED = 47
852 VK_FORMAT_B8G8R8A8_UINT = 48
853 VK_FORMAT_B8G8R8A8_SINT = 49
854 VK_FORMAT_B8G8R8A8_SRGB = 50
855 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51
856 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52
857 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53
858 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54
859 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55
860 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56
861 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57
862 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58
863 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59
864 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60
865 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61
866 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62
867 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63
868 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64
869 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65
870 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66
871 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67
872 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68
873 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69
874 VK_FORMAT_R16_UNORM = 70
875 VK_FORMAT_R16_SNORM = 71
876 VK_FORMAT_R16_USCALED = 72
877 VK_FORMAT_R16_SSCALED = 73
878 VK_FORMAT_R16_UINT = 74
879 VK_FORMAT_R16_SINT = 75
880 VK_FORMAT_R16_SFLOAT = 76
881 VK_FORMAT_R16G16_UNORM = 77
882 VK_FORMAT_R16G16_SNORM = 78
883 VK_FORMAT_R16G16_USCALED = 79
884 VK_FORMAT_R16G16_SSCALED = 80
885 VK_FORMAT_R16G16_UINT = 81
886 VK_FORMAT_R16G16_SINT = 82
887 VK_FORMAT_R16G16_SFLOAT = 83
888 VK_FORMAT_R16G16B16_UNORM = 84
889 VK_FORMAT_R16G16B16_SNORM = 85
890 VK_FORMAT_R16G16B16_USCALED = 86
891 VK_FORMAT_R16G16B16_SSCALED = 87
892 VK_FORMAT_R16G16B16_UINT = 88
893 VK_FORMAT_R16G16B16_SINT = 89
894 VK_FORMAT_R16G16B16_SFLOAT = 90
895 VK_FORMAT_R16G16B16A16_UNORM = 91
896 VK_FORMAT_R16G16B16A16_SNORM = 92
897 VK_FORMAT_R16G16B16A16_USCALED = 93
898 VK_FORMAT_R16G16B16A16_SSCALED = 94
899 VK_FORMAT_R16G16B16A16_UINT = 95
900 VK_FORMAT_R16G16B16A16_SINT = 96
901 VK_FORMAT_R16G16B16A16_SFLOAT = 97
902 VK_FORMAT_R32_UINT = 98
903 VK_FORMAT_R32_SINT = 99
904 VK_FORMAT_R32_SFLOAT = 100
905 VK_FORMAT_R32G32_UINT = 101
906 VK_FORMAT_R32G32_SINT = 102
907 VK_FORMAT_R32G32_SFLOAT = 103
908 VK_FORMAT_R32G32B32_UINT = 104
909 VK_FORMAT_R32G32B32_SINT = 105
910 VK_FORMAT_R32G32B32_SFLOAT = 106
911 VK_FORMAT_R32G32B32A32_UINT = 107
912 VK_FORMAT_R32G32B32A32_SINT = 108
913 VK_FORMAT_R32G32B32A32_SFLOAT = 109
914 VK_FORMAT_R64_UINT = 110
915 VK_FORMAT_R64_SINT = 111
916 VK_FORMAT_R64_SFLOAT = 112
917 VK_FORMAT_R64G64_UINT = 113
918 VK_FORMAT_R64G64_SINT = 114
919 VK_FORMAT_R64G64_SFLOAT = 115
920 VK_FORMAT_R64G64B64_UINT = 116
921 VK_FORMAT_R64G64B64_SINT = 117
922 VK_FORMAT_R64G64B64_SFLOAT = 118
923 VK_FORMAT_R64G64B64A64_UINT = 119
924 VK_FORMAT_R64G64B64A64_SINT = 120
925 VK_FORMAT_R64G64B64A64_SFLOAT = 121
926 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122
927 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123
928 VK_FORMAT_D16_UNORM = 124
929 VK_FORMAT_X8_D24_UNORM_PACK32 = 125
930 VK_FORMAT_D32_SFLOAT = 126
931 VK_FORMAT_S8_UINT = 127
932 VK_FORMAT_D16_UNORM_S8_UINT = 128
933 VK_FORMAT_D24_UNORM_S8_UINT = 129
934 VK_FORMAT_D32_SFLOAT_S8_UINT = 130
935 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131
936 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132
937 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133
938 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134
939 VK_FORMAT_BC2_UNORM_BLOCK = 135
940 VK_FORMAT_BC2_SRGB_BLOCK = 136
941 VK_FORMAT_BC3_UNORM_BLOCK = 137
942 VK_FORMAT_BC3_SRGB_BLOCK = 138
943 VK_FORMAT_BC4_UNORM_BLOCK = 139
944 VK_FORMAT_BC4_SNORM_BLOCK = 140
945 VK_FORMAT_BC5_UNORM_BLOCK = 141
946 VK_FORMAT_BC5_SNORM_BLOCK = 142
947 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143
948 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144
949 VK_FORMAT_BC7_UNORM_BLOCK = 145
950 VK_FORMAT_BC7_SRGB_BLOCK = 146
951 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147
952 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148
953 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149
954 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150
955 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151
956 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152
957 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153
958 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154
959 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155
960 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156
961 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157
962 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158
963 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159
964 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160
965 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161
966 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162
967 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163
968 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164
969 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165
970 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166
971 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167
972 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168
973 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169
974 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170
975 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171
976 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172
977 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173
978 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174
979 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175
980 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176
981 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177
982 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178
983 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179
984 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180
985 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181
986 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182
987 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183
988 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184
989 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000
990 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001
991 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002
992 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003
993 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004
994 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005
995 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006
996 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007
997 VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000
998 VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001
999 VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002
1000 VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003
1001 VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004
1002 VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005
1003 VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006
1004 VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007
1005 VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008
1006 VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009
1007 VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010
1008 VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011
1009 VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012
1010 VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013
1011 VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000
1012 VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001
1013 VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002
1014 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003
1015 VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004
1016 VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005
1017 VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006
1018 VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007
1019 VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008
1020 VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009
1021 VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010
1022 VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011
1023 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012
1024 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013
1025 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014
1026 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015
1027 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016
1028 VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017
1029 VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018
1030 VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019
1031 VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020
1032 VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021
1033 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022
1034 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023
1035 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024
1036 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025
1037 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026
1038 VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027
1039 VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028
1040 VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029
1041 VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030
1042 VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031
1043 VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032
1044 VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033
1045 VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT = 1000288000
1046 VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT = 1000288001
1047 VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT = 1000288002
1048 VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT = 1000288003
1049 VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT = 1000288004
1050 VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT = 1000288005
1051 VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT = 1000288006
1052 VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT = 1000288007
1053 VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT = 1000288008
1054 VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT = 1000288009
1055 VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT = 1000288010
1056 VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT = 1000288011
1057 VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT = 1000288012
1058 VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT = 1000288013
1059 VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT = 1000288014
1060 VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT = 1000288015
1061 VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT = 1000288016
1062 VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT = 1000288017
1063 VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT = 1000288018
1064 VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT = 1000288019
1065 VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT = 1000288020
1066 VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT = 1000288021
1067 VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT = 1000288022
1068 VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT = 1000288023
1069 VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT = 1000288024
1070 VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT = 1000288025
1071 VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT = 1000288026
1072 VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT = 1000288027
1073 VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT = 1000288028
1074 VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT = 1000288029
1075 VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000
1076 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001
1077 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002
1078 VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003
1079 VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000
1080 VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001
1081 VK_FORMAT_R16G16_S10_5_NV = 1000464000
1082 VkStructureType* {.size: sizeof(cint).} = enum
1083 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0
1084 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1
1085 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2
1086 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3
1087 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4
1088 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5
1089 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6
1090 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7
1091 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8
1092 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9
1093 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10
1094 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11
1095 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12
1096 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13
1097 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14
1098 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15
1099 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16
1100 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17
1101 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18
1102 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19
1103 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20
1104 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21
1105 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22
1106 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23
1107 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24
1108 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25
1109 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26
1110 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27
1111 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28
1112 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29
1113 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30
1114 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31
1115 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32
1116 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33
1117 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34
1118 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35
1119 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36
1120 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37
1121 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38
1122 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39
1123 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40
1124 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41
1125 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42
1126 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43
1127 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44
1128 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45
1129 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46
1130 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47
1131 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48
1132 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49
1133 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50
1134 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51
1135 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52
1136 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53
1137 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54
1138 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000
1139 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001
1140 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000
1141 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001
1142 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000
1143 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000
1144 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000
1145 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000
1146 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000
1147 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000
1148 VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID = 1000010000
1149 VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID = 1000010001
1150 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID = 1000010002
1151 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000
1152 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000
1153 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000
1154 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001
1155 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002
1156 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000
1157 VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001
1158 VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002
1159 VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003
1160 VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004
1161 VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005
1162 VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006
1163 VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007
1164 VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008
1165 VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009
1166 VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010
1167 VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011
1168 VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012
1169 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013
1170 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014
1171 VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015
1172 VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016
1173 VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000
1174 VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001
1175 VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002
1176 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000
1177 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001
1178 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002
1179 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000
1180 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001
1181 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002
1182 VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000
1183 VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001
1184 VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002
1185 VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000
1186 VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001
1187 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000
1188 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001
1189 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002
1190 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003
1191 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004
1192 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005
1193 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000038006
1194 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007
1195 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008
1196 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009
1197 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT = 1000038010
1198 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000
1199 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001
1200 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002
1201 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003
1202 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004
1203 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005
1204 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000039006
1205 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007
1206 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT = 1000039008
1207 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009
1208 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010
1209 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000
1210 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001
1211 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003
1212 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004
1213 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005
1214 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006
1215 VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000
1216 VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000
1217 VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001
1218 VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002
1219 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003
1220 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004
1221 VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006
1222 VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007
1223 VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008
1224 VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009
1225 VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000
1226 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000
1227 VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_RESERVED_OFFSET_0_NV = 1000051000
1228 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000
1229 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001
1230 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002
1231 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000
1232 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001
1233 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000
1234 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001
1235 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000
1236 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000
1237 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001
1238 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002
1239 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003
1240 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004
1241 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005
1242 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006
1243 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007
1244 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008
1245 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000
1246 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003
1247 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004
1248 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005
1249 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006
1250 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007
1251 VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008
1252 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009
1253 VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010
1254 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011
1255 VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012
1256 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013
1257 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014
1258 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000
1259 VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000
1260 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000
1261 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000
1262 VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000
1263 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001
1264 VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000
1265 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001
1266 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002
1267 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000
1268 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001
1269 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000
1270 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001
1271 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002
1272 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003
1273 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004
1274 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000
1275 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001
1276 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002
1277 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000
1278 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001
1279 VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002
1280 VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003
1281 VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000
1282 VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001
1283 VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002
1284 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000
1285 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000
1286 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001
1287 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000
1288 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000
1289 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001
1290 VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002
1291 VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003
1292 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000
1293 VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001
1294 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000
1295 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000
1296 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001
1297 VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002
1298 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000
1299 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000
1300 VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000
1301 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000
1302 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000
1303 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000
1304 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000
1305 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001
1306 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002
1307 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003
1308 VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000
1309 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000
1310 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000
1311 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000
1312 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000
1313 VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001
1314 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000
1315 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001
1316 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000
1317 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001
1318 VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000
1319 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000
1320 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001
1321 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002
1322 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003
1323 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000
1324 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001
1325 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002
1326 VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003
1327 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004
1328 VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005
1329 VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006
1330 VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000
1331 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000
1332 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001
1333 VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000
1334 VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000
1335 VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001
1336 VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002
1337 VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000
1338 VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001
1339 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000
1340 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001
1341 VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002
1342 VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003
1343 VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004
1344 VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005
1345 VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006
1346 VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR = 1000116007
1347 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000
1348 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001
1349 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002
1350 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003
1351 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000
1352 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001
1353 VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002
1354 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000
1355 VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000
1356 VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001
1357 VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002
1358 VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003
1359 VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004
1360 VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000
1361 VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000
1362 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000
1363 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001
1364 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000
1365 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001
1366 VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002
1367 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003
1368 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004
1369 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000
1370 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001
1371 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002
1372 VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003
1373 VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004
1374 VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005
1375 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006
1376 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000
1377 VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001
1378 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000
1379 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001
1380 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002
1381 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003
1382 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000
1383 VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001
1384 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002
1385 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003
1386 VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004
1387 VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000
1388 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001
1389 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002
1390 VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003
1391 VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000
1392 VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001
1393 VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002
1394 VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003
1395 VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004
1396 VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000
1397 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000
1398 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001
1399 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002
1400 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000
1401 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000
1402 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002
1403 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003
1404 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004
1405 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005
1406 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006
1407 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007
1408 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009
1409 VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010
1410 VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011
1411 VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012
1412 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013
1413 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014
1414 VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015
1415 VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016
1416 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017
1417 VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018
1418 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020
1419 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000
1420 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000
1421 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001
1422 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000
1423 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001
1424 VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002
1425 VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003
1426 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004
1427 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005
1428 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000
1429 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001
1430 VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000
1431 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002
1432 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003
1433 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004
1434 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005
1435 VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006
1436 VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000
1437 VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001
1438 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000
1439 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001
1440 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002
1441 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003
1442 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004
1443 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000
1444 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001
1445 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000
1446 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001
1447 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002
1448 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005
1449 VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000
1450 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001
1451 VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003
1452 VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004
1453 VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005
1454 VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006
1455 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007
1456 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008
1457 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009
1458 VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011
1459 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012
1460 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000
1461 VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001
1462 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000
1463 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001
1464 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000
1465 VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001
1466 VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000
1467 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000
1468 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000
1469 VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000
1470 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001
1471 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002
1472 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000
1473 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000
1474 VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000
1475 VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000
1476 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000
1477 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000
1478 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001
1479 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002
1480 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003
1481 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004
1482 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005
1483 VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000
1484 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000
1485 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001
1486 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002
1487 VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000
1488 VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000
1489 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000
1490 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000
1491 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000
1492 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001
1493 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000
1494 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000
1495 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001
1496 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000
1497 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000
1498 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000
1499 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002
1500 VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000
1501 VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001
1502 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000
1503 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001
1504 VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002
1505 VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003
1506 VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004
1507 VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005
1508 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000
1509 VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000
1510 VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001
1511 VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002
1512 VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003
1513 VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004
1514 VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005
1515 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000
1516 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000
1517 VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000
1518 VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001
1519 VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000
1520 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000
1521 VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000
1522 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000
1523 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001
1524 VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002
1525 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000
1526 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000
1527 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001
1528 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002
1529 VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000
1530 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001
1531 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002
1532 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003
1533 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004
1534 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000
1535 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000
1536 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000
1537 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000
1538 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000
1539 VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001
1540 VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000
1541 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000
1542 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000
1543 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001
1544 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002
1545 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000
1546 VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001
1547 VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002
1548 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000
1549 VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000
1550 VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000
1551 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000
1552 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000
1553 VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001
1554 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002
1555 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000
1556 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001
1557 VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002
1558 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000
1559 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000
1560 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000
1561 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000
1562 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001
1563 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002
1564 VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000
1565 VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001
1566 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002
1567 VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000
1568 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000
1569 VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002
1570 VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003
1571 VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004
1572 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000
1573 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001
1574 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002
1575 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000
1576 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000
1577 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000
1578 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000
1579 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000
1580 VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001
1581 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002
1582 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003
1583 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004
1584 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005
1585 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000
1586 VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000
1587 VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001
1588 VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002
1589 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000
1590 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001
1591 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002
1592 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003
1593 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004
1594 VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005
1595 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000
1596 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000
1597 VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001
1598 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002
1599 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003
1600 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004
1601 VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005
1602 VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006
1603 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007
1604 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000
1605 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001
1606 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000
1607 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001
1608 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000
1609 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001
1610 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000
1611 VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001
1612 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000
1613 VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001
1614 VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002
1615 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000
1616 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001
1617 VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000
1618 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001
1619 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002
1620 VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000
1621 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000
1622 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001
1623 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002
1624 VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000
1625 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001
1626 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000
1627 VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001
1628 VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002
1629 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000
1630 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES = 1000298000
1631 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES = 1000298001
1632 VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO = 1000298002
1633 VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO = 1000298003
1634 VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION = 1000298004
1635 VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE = 1000298005
1636 VK_STRUCTURE_TYPE_FAULT_DATA = 1000298007
1637 VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO = 1000298008
1638 VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO = 1000298010
1639 VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000
1640 VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001
1641 VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002
1642 VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003
1643 VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004
1644 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000
1645 VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001
1646 VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR = 1000308000
1647 VK_STRUCTURE_TYPE_RESERVED_QCOM = 1000309000
1648 VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000
1649 VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001
1650 VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002
1651 VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003
1652 VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004
1653 VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005
1654 VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006
1655 VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007
1656 VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008
1657 VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009
1658 VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010
1659 VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011
1660 VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000
1661 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001
1662 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002
1663 VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003
1664 VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004
1665 VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005
1666 VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006
1667 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007
1668 VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008
1669 VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009
1670 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000
1671 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001
1672 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002
1673 VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003
1674 VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004
1675 VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005
1676 VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006
1677 VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007
1678 VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008
1679 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009
1680 VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010
1681 VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011
1682 VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012
1683 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000
1684 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001
1685 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002
1686 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000
1687 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000
1688 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000
1689 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000
1690 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000
1691 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001
1692 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002
1693 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000
1694 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001
1695 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002
1696 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000
1697 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001
1698 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000
1699 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000
1700 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001
1701 VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000
1702 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000
1703 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000
1704 VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000
1705 VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001
1706 VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002
1707 VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003
1708 VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004
1709 VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005
1710 VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006
1711 VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007
1712 VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008
1713 VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009
1714 VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010
1715 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000
1716 VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001
1717 VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = 1000338002
1718 VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = 1000338003
1719 VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004
1720 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000
1721 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000
1722 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000
1723 VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001
1724 VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002
1725 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000
1726 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000
1727 VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000
1728 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000
1729 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001
1730 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013
1731 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000
1732 VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002
1733 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000
1734 VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001
1735 VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002
1736 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000
1737 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000
1738 VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001
1739 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000
1740 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001
1741 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000
1742 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000
1743 VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000
1744 VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001
1745 VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002
1746 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000
1747 VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001
1748 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000
1749 VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001
1750 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002
1751 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003
1752 VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004
1753 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005
1754 VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006
1755 VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007
1756 VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008
1757 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009
1758 VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000
1759 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001
1760 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002
1761 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000
1762 VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000
1763 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001
1764 VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000
1765 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001
1766 VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV = 1000373000
1767 VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV = 1000373001
1768 VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV = 1000373002
1769 VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV = 1000373003
1770 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV = 1000373004
1771 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV = 1000373005
1772 VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV = 1000373006
1773 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV = 1000373007
1774 VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV = 1000374000
1775 VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV = 1000374001
1776 VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV = 1000374002
1777 VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV = 1000374003
1778 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV = 1000374004
1779 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000
1780 VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001
1781 VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002
1782 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000
1783 VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000
1784 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000
1785 VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001
1786 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000
1787 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000
1788 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000
1789 VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001
1790 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000
1791 VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001
1792 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000
1793 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001
1794 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000
1795 VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000
1796 VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001
1797 VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002
1798 VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003
1799 VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004
1800 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005
1801 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006
1802 VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007
1803 VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008
1804 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009
1805 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000
1806 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001
1807 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000
1808 VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001
1809 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000
1810 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000
1811 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001
1812 VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002
1813 VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003
1814 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000
1815 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000
1816 VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001
1817 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000
1818 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001
1819 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002
1820 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000
1821 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000
1822 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000
1823 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001
1824 VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002
1825 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000
1826 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001
1827 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000
1828 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001
1829 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000
1830 VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT = 1000435000
1831 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000
1832 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000
1833 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001
1834 VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002
1835 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000
1836 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001
1837 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000
1838 VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001
1839 VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002
1840 VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003
1841 VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000
1842 VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001
1843 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000
1844 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001
1845 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002
1846 VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003
1847 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000
1848 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001
1849 VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002
1850 VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003
1851 VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004
1852 VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005
1853 VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010
1854 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000
1855 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000
1856 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000
1857 VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001
1858 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000
1859 VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001
1860 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000
1861 VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV = 1000489000
1862 VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV = 1000489001
1863 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV = 1000489002
1864 VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV = 1000489003
1865 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000
1866 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001
1867 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000
1868 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001
1869 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000
1870 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000
1871 VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001
1872 VkSubpassContents* {.size: sizeof(cint).} = enum
1873 VK_SUBPASS_CONTENTS_INLINE = 0
1874 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
1875 VkResult* {.size: sizeof(cint).} = enum
1876 VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000
1877 VK_ERROR_NO_PIPELINE_MATCH = -1000298001
1878 VK_ERROR_INVALID_PIPELINE_CACHE_DATA = -1000298000
1879 VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000
1880 VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000
1881 VK_ERROR_NOT_PERMITTED_KHR = -1000174001
1882 VK_ERROR_FRAGMENTATION = -1000161000
1883 VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000
1884 VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003
1885 VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000
1886 VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005
1887 VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004
1888 VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003
1889 VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002
1890 VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001
1891 VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000
1892 VK_ERROR_INVALID_SHADER_NV = -1000012000
1893 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001
1894 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001
1895 VK_ERROR_OUT_OF_DATE_KHR = -1000001004
1896 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001
1897 VK_ERROR_SURFACE_LOST_KHR = -1000000000
1898 VK_ERROR_UNKNOWN = -13
1899 VK_ERROR_FRAGMENTED_POOL = -12
1900 VK_ERROR_FORMAT_NOT_SUPPORTED = -11
1901 VK_ERROR_TOO_MANY_OBJECTS = -10
1902 VK_ERROR_INCOMPATIBLE_DRIVER = -9
1903 VK_ERROR_FEATURE_NOT_PRESENT = -8
1904 VK_ERROR_EXTENSION_NOT_PRESENT = -7
1905 VK_ERROR_LAYER_NOT_PRESENT = -6
1906 VK_ERROR_MEMORY_MAP_FAILED = -5
1907 VK_ERROR_DEVICE_LOST = -4
1908 VK_ERROR_INITIALIZATION_FAILED = -3
1909 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2
1910 VK_ERROR_OUT_OF_HOST_MEMORY = -1
1911 VK_SUCCESS = 0
1912 VK_NOT_READY = 1
1913 VK_TIMEOUT = 2
1914 VK_EVENT_SET = 3
1915 VK_EVENT_RESET = 4
1916 VK_INCOMPLETE = 5
1917 VK_SUBOPTIMAL_KHR = 1000001003
1918 VK_THREAD_IDLE_KHR = 1000268000
1919 VK_THREAD_DONE_KHR = 1000268001
1920 VK_OPERATION_DEFERRED_KHR = 1000268002
1921 VK_OPERATION_NOT_DEFERRED_KHR = 1000268003
1922 VK_PIPELINE_COMPILE_REQUIRED = 1000297000
1923 VkDynamicState* {.size: sizeof(cint).} = enum
1924 VK_DYNAMIC_STATE_VIEWPORT = 0
1925 VK_DYNAMIC_STATE_SCISSOR = 1
1926 VK_DYNAMIC_STATE_LINE_WIDTH = 2
1927 VK_DYNAMIC_STATE_DEPTH_BIAS = 3
1928 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4
1929 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5
1930 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6
1931 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7
1932 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8
1933 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000
1934 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000
1935 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001
1936 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002
1937 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000
1938 VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004
1939 VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006
1940 VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000
1941 VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001
1942 VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000
1943 VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000
1944 VK_DYNAMIC_STATE_CULL_MODE = 1000267000
1945 VK_DYNAMIC_STATE_FRONT_FACE = 1000267001
1946 VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002
1947 VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003
1948 VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004
1949 VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005
1950 VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006
1951 VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007
1952 VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008
1953 VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009
1954 VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010
1955 VK_DYNAMIC_STATE_STENCIL_OP = 1000267011
1956 VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000
1957 VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000
1958 VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000
1959 VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001
1960 VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002
1961 VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003
1962 VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004
1963 VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000
1964 VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002
1965 VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003
1966 VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004
1967 VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005
1968 VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006
1969 VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007
1970 VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008
1971 VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009
1972 VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010
1973 VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011
1974 VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012
1975 VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013
1976 VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014
1977 VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015
1978 VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016
1979 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017
1980 VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018
1981 VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019
1982 VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020
1983 VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021
1984 VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022
1985 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023
1986 VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024
1987 VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025
1988 VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026
1989 VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027
1990 VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028
1991 VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029
1992 VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030
1993 VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031
1994 VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032
1995 VkDescriptorUpdateTemplateType* {.size: sizeof(cint).} = enum
1996 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0
1997 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1
1998 VkObjectType* {.size: sizeof(cint).} = enum
1999 VK_OBJECT_TYPE_UNKNOWN = 0
2000 VK_OBJECT_TYPE_INSTANCE = 1
2001 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2
2002 VK_OBJECT_TYPE_DEVICE = 3
2003 VK_OBJECT_TYPE_QUEUE = 4
2004 VK_OBJECT_TYPE_SEMAPHORE = 5
2005 VK_OBJECT_TYPE_COMMAND_BUFFER = 6
2006 VK_OBJECT_TYPE_FENCE = 7
2007 VK_OBJECT_TYPE_DEVICE_MEMORY = 8
2008 VK_OBJECT_TYPE_BUFFER = 9
2009 VK_OBJECT_TYPE_IMAGE = 10
2010 VK_OBJECT_TYPE_EVENT = 11
2011 VK_OBJECT_TYPE_QUERY_POOL = 12
2012 VK_OBJECT_TYPE_BUFFER_VIEW = 13
2013 VK_OBJECT_TYPE_IMAGE_VIEW = 14
2014 VK_OBJECT_TYPE_SHADER_MODULE = 15
2015 VK_OBJECT_TYPE_PIPELINE_CACHE = 16
2016 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17
2017 VK_OBJECT_TYPE_RENDER_PASS = 18
2018 VK_OBJECT_TYPE_PIPELINE = 19
2019 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20
2020 VK_OBJECT_TYPE_SAMPLER = 21
2021 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22
2022 VK_OBJECT_TYPE_DESCRIPTOR_SET = 23
2023 VK_OBJECT_TYPE_FRAMEBUFFER = 24
2024 VK_OBJECT_TYPE_COMMAND_POOL = 25
2025 VK_OBJECT_TYPE_SURFACE_KHR = 1000000000
2026 VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000
2027 VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000
2028 VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001
2029 VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000
2030 VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000
2031 VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001
2032 VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000
2033 VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001
2034 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000
2035 VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000
2036 VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000
2037 VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000
2038 VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000
2039 VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000
2040 VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000
2041 VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000
2042 VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000
2043 VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000
2044 VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000
2045 VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000
2046 VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000
2047 VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV = 1000489000
2048 VkRayTracingInvocationReorderModeNV* {.size: sizeof(cint).} = enum
2049 VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0
2050 VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1
2051 VkDirectDriverLoadingModeLUNARG* {.size: sizeof(cint).} = enum
2052 VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0
2053 VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1
2054 VkQueueFlagBits* {.size: sizeof(cint).} = enum
2055 VK_QUEUE_GRAPHICS_BIT = 0b00000000000000000000000000000001
2056 VK_QUEUE_COMPUTE_BIT = 0b00000000000000000000000000000010
2057 VK_QUEUE_TRANSFER_BIT = 0b00000000000000000000000000000100
2058 VK_QUEUE_SPARSE_BINDING_BIT = 0b00000000000000000000000000001000
2059 VK_QUEUE_PROTECTED_BIT = 0b00000000000000000000000000010000
2060 VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0b00000000000000000000000000100000
2061 VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0b00000000000000000000000001000000
2062 VK_QUEUE_RESERVED_7_BIT_QCOM = 0b00000000000000000000000010000000
2063 VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0b00000000000000000000000100000000
2064 VK_QUEUE_RESERVED_9_BIT_EXT = 0b00000000000000000000001000000000
2065 func toBits*(flags: openArray[VkQueueFlagBits]): VkQueueFlags =
2066 for flag in flags:
2067 result = VkQueueFlags(uint(result) or uint(flag))
2068 func toEnums*(number: VkQueueFlags): seq[VkQueueFlagBits] =
2069 for value in VkQueueFlagBits.items:
2070 if (value.ord and cint(number)) > 0:
2071 result.add value
2072 proc `==`*(a, b: VkQueueFlags): bool = cint(a) == cint(b)
2073 type
2074 VkCullModeFlagBits* {.size: sizeof(cint).} = enum
2075 VK_CULL_MODE_FRONT_BIT = 0b00000000000000000000000000000001
2076 VK_CULL_MODE_BACK_BIT = 0b00000000000000000000000000000010
2077 func toBits*(flags: openArray[VkCullModeFlagBits]): VkCullModeFlags =
2078 for flag in flags:
2079 result = VkCullModeFlags(uint(result) or uint(flag))
2080 func toEnums*(number: VkCullModeFlags): seq[VkCullModeFlagBits] =
2081 for value in VkCullModeFlagBits.items:
2082 if (value.ord and cint(number)) > 0:
2083 result.add value
2084 proc `==`*(a, b: VkCullModeFlags): bool = cint(a) == cint(b)
2085 const
2086 VK_CULL_MODE_NONE* = 0
2087 VK_CULL_MODE_FRONT_AND_BACK* = 0x00000003
2088 type
2089 VkRenderPassCreateFlagBits* {.size: sizeof(cint).} = enum
2090 VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR = 0b00000000000000000000000000000001
2091 VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0b00000000000000000000000000000010
2092 func toBits*(flags: openArray[VkRenderPassCreateFlagBits]): VkRenderPassCreateFlags =
2093 for flag in flags:
2094 result = VkRenderPassCreateFlags(uint(result) or uint(flag))
2095 func toEnums*(number: VkRenderPassCreateFlags): seq[VkRenderPassCreateFlagBits] =
2096 for value in VkRenderPassCreateFlagBits.items:
2097 if (value.ord and cint(number)) > 0:
2098 result.add value
2099 proc `==`*(a, b: VkRenderPassCreateFlags): bool = cint(a) == cint(b)
2100 type
2101 VkDeviceQueueCreateFlagBits* {.size: sizeof(cint).} = enum
2102 VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0b00000000000000000000000000000001
2103 VK_DEVICE_QUEUE_CREATE_RESERVED_1_BIT_QCOM = 0b00000000000000000000000000000010
2104 func toBits*(flags: openArray[VkDeviceQueueCreateFlagBits]): VkDeviceQueueCreateFlags =
2105 for flag in flags:
2106 result = VkDeviceQueueCreateFlags(uint(result) or uint(flag))
2107 func toEnums*(number: VkDeviceQueueCreateFlags): seq[VkDeviceQueueCreateFlagBits] =
2108 for value in VkDeviceQueueCreateFlagBits.items:
2109 if (value.ord and cint(number)) > 0:
2110 result.add value
2111 proc `==`*(a, b: VkDeviceQueueCreateFlags): bool = cint(a) == cint(b)
2112 type
2113 VkMemoryPropertyFlagBits* {.size: sizeof(cint).} = enum
2114 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0b00000000000000000000000000000001
2115 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0b00000000000000000000000000000010
2116 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0b00000000000000000000000000000100
2117 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0b00000000000000000000000000001000
2118 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0b00000000000000000000000000010000
2119 VK_MEMORY_PROPERTY_PROTECTED_BIT = 0b00000000000000000000000000100000
2120 VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0b00000000000000000000000001000000
2121 VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0b00000000000000000000000010000000
2122 VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0b00000000000000000000000100000000
2123 func toBits*(flags: openArray[VkMemoryPropertyFlagBits]): VkMemoryPropertyFlags =
2124 for flag in flags:
2125 result = VkMemoryPropertyFlags(uint(result) or uint(flag))
2126 func toEnums*(number: VkMemoryPropertyFlags): seq[VkMemoryPropertyFlagBits] =
2127 for value in VkMemoryPropertyFlagBits.items:
2128 if (value.ord and cint(number)) > 0:
2129 result.add value
2130 proc `==`*(a, b: VkMemoryPropertyFlags): bool = cint(a) == cint(b)
2131 type
2132 VkMemoryHeapFlagBits* {.size: sizeof(cint).} = enum
2133 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0b00000000000000000000000000000001
2134 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0b00000000000000000000000000000010
2135 VK_MEMORY_HEAP_SEU_SAFE_BIT = 0b00000000000000000000000000000100
2136 func toBits*(flags: openArray[VkMemoryHeapFlagBits]): VkMemoryHeapFlags =
2137 for flag in flags:
2138 result = VkMemoryHeapFlags(uint(result) or uint(flag))
2139 func toEnums*(number: VkMemoryHeapFlags): seq[VkMemoryHeapFlagBits] =
2140 for value in VkMemoryHeapFlagBits.items:
2141 if (value.ord and cint(number)) > 0:
2142 result.add value
2143 proc `==`*(a, b: VkMemoryHeapFlags): bool = cint(a) == cint(b)
2144 type
2145 VkAccessFlagBits* {.size: sizeof(cint).} = enum
2146 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0b00000000000000000000000000000001
2147 VK_ACCESS_INDEX_READ_BIT = 0b00000000000000000000000000000010
2148 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0b00000000000000000000000000000100
2149 VK_ACCESS_UNIFORM_READ_BIT = 0b00000000000000000000000000001000
2150 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0b00000000000000000000000000010000
2151 VK_ACCESS_SHADER_READ_BIT = 0b00000000000000000000000000100000
2152 VK_ACCESS_SHADER_WRITE_BIT = 0b00000000000000000000000001000000
2153 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0b00000000000000000000000010000000
2154 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0b00000000000000000000000100000000
2155 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0b00000000000000000000001000000000
2156 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0b00000000000000000000010000000000
2157 VK_ACCESS_TRANSFER_READ_BIT = 0b00000000000000000000100000000000
2158 VK_ACCESS_TRANSFER_WRITE_BIT = 0b00000000000000000001000000000000
2159 VK_ACCESS_HOST_READ_BIT = 0b00000000000000000010000000000000
2160 VK_ACCESS_HOST_WRITE_BIT = 0b00000000000000000100000000000000
2161 VK_ACCESS_MEMORY_READ_BIT = 0b00000000000000001000000000000000
2162 VK_ACCESS_MEMORY_WRITE_BIT = 0b00000000000000010000000000000000
2163 VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0b00000000000000100000000000000000
2164 VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0b00000000000001000000000000000000
2165 VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0b00000000000010000000000000000000
2166 VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0b00000000000100000000000000000000
2167 VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0b00000000001000000000000000000000
2168 VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0b00000000010000000000000000000000
2169 VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0b00000000100000000000000000000000
2170 VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0b00000001000000000000000000000000
2171 VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0b00000010000000000000000000000000
2172 VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0b00000100000000000000000000000000
2173 VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0b00001000000000000000000000000000
2174 func toBits*(flags: openArray[VkAccessFlagBits]): VkAccessFlags =
2175 for flag in flags:
2176 result = VkAccessFlags(uint(result) or uint(flag))
2177 func toEnums*(number: VkAccessFlags): seq[VkAccessFlagBits] =
2178 for value in VkAccessFlagBits.items:
2179 if (value.ord and cint(number)) > 0:
2180 result.add value
2181 proc `==`*(a, b: VkAccessFlags): bool = cint(a) == cint(b)
2182 type
2183 VkBufferUsageFlagBits* {.size: sizeof(cint).} = enum
2184 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0b00000000000000000000000000000001
2185 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0b00000000000000000000000000000010
2186 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0b00000000000000000000000000000100
2187 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0b00000000000000000000000000001000
2188 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0b00000000000000000000000000010000
2189 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0b00000000000000000000000000100000
2190 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0b00000000000000000000000001000000
2191 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0b00000000000000000000000010000000
2192 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0b00000000000000000000000100000000
2193 VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0b00000000000000000000001000000000
2194 VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0b00000000000000000000010000000000
2195 VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0b00000000000000000000100000000000
2196 VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0b00000000000000000001000000000000
2197 VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0b00000000000000000010000000000000
2198 VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0b00000000000000000100000000000000
2199 VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0b00000000000000001000000000000000
2200 VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0b00000000000000010000000000000000
2201 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0b00000000000000100000000000000000
2202 VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM = 0b00000000000001000000000000000000
2203 VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0b00000000000010000000000000000000
2204 VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0b00000000000100000000000000000000
2205 VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000000001000000000000000000000
2206 VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000000010000000000000000000000
2207 VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0b00000000100000000000000000000000
2208 VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0b00000001000000000000000000000000
2209 VK_BUFFER_USAGE_RESERVED_25_BIT_AMD = 0b00000010000000000000000000000000
2210 VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000100000000000000000000000000
2211 func toBits*(flags: openArray[VkBufferUsageFlagBits]): VkBufferUsageFlags =
2212 for flag in flags:
2213 result = VkBufferUsageFlags(uint(result) or uint(flag))
2214 func toEnums*(number: VkBufferUsageFlags): seq[VkBufferUsageFlagBits] =
2215 for value in VkBufferUsageFlagBits.items:
2216 if (value.ord and cint(number)) > 0:
2217 result.add value
2218 proc `==`*(a, b: VkBufferUsageFlags): bool = cint(a) == cint(b)
2219 type
2220 VkBufferCreateFlagBits* {.size: sizeof(cint).} = enum
2221 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0b00000000000000000000000000000001
2222 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0b00000000000000000000000000000010
2223 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0b00000000000000000000000000000100
2224 VK_BUFFER_CREATE_PROTECTED_BIT = 0b00000000000000000000000000001000
2225 VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0b00000000000000000000000000010000
2226 VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000100000
2227 func toBits*(flags: openArray[VkBufferCreateFlagBits]): VkBufferCreateFlags =
2228 for flag in flags:
2229 result = VkBufferCreateFlags(uint(result) or uint(flag))
2230 func toEnums*(number: VkBufferCreateFlags): seq[VkBufferCreateFlagBits] =
2231 for value in VkBufferCreateFlagBits.items:
2232 if (value.ord and cint(number)) > 0:
2233 result.add value
2234 proc `==`*(a, b: VkBufferCreateFlags): bool = cint(a) == cint(b)
2235 type
2236 VkShaderStageFlagBits* {.size: sizeof(cint).} = enum
2237 VK_SHADER_STAGE_VERTEX_BIT = 0b00000000000000000000000000000001
2238 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0b00000000000000000000000000000010
2239 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0b00000000000000000000000000000100
2240 VK_SHADER_STAGE_GEOMETRY_BIT = 0b00000000000000000000000000001000
2241 VK_SHADER_STAGE_FRAGMENT_BIT = 0b00000000000000000000000000010000
2242 VK_SHADER_STAGE_COMPUTE_BIT = 0b00000000000000000000000000100000
2243 VK_SHADER_STAGE_TASK_BIT_EXT = 0b00000000000000000000000001000000
2244 VK_SHADER_STAGE_MESH_BIT_EXT = 0b00000000000000000000000010000000
2245 VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0b00000000000000000000000100000000
2246 VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0b00000000000000000000001000000000
2247 VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0b00000000000000000000010000000000
2248 VK_SHADER_STAGE_MISS_BIT_KHR = 0b00000000000000000000100000000000
2249 VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0b00000000000000000001000000000000
2250 VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0b00000000000000000010000000000000
2251 VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0b00000000000000000100000000000000
2252 VK_SHADER_STAGE_EXT_483_RESERVE_15 = 0b00000000000000001000000000000000
2253 VK_SHADER_STAGE_EXT_483_RESERVE_16 = 0b00000000000000010000000000000000
2254 VK_SHADER_STAGE_EXT_483_RESERVE_17 = 0b00000000000000100000000000000000
2255 VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0b00000000000010000000000000000000
2256 func toBits*(flags: openArray[VkShaderStageFlagBits]): VkShaderStageFlags =
2257 for flag in flags:
2258 result = VkShaderStageFlags(uint(result) or uint(flag))
2259 func toEnums*(number: VkShaderStageFlags): seq[VkShaderStageFlagBits] =
2260 for value in VkShaderStageFlagBits.items:
2261 if (value.ord and cint(number)) > 0:
2262 result.add value
2263 proc `==`*(a, b: VkShaderStageFlags): bool = cint(a) == cint(b)
2264 const
2265 VK_SHADER_STAGE_ALL_GRAPHICS* = 0x0000001F
2266 VK_SHADER_STAGE_ALL* = 0x7FFFFFFF
2267 type
2268 VkImageUsageFlagBits* {.size: sizeof(cint).} = enum
2269 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0b00000000000000000000000000000001
2270 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0b00000000000000000000000000000010
2271 VK_IMAGE_USAGE_SAMPLED_BIT = 0b00000000000000000000000000000100
2272 VK_IMAGE_USAGE_STORAGE_BIT = 0b00000000000000000000000000001000
2273 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0b00000000000000000000000000010000
2274 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0b00000000000000000000000000100000
2275 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0b00000000000000000000000001000000
2276 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0b00000000000000000000000010000000
2277 VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b00000000000000000000000100000000
2278 VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0b00000000000000000000001000000000
2279 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0b00000000000000000000010000000000
2280 VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0b00000000000000000000100000000000
2281 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0b00000000000000000001000000000000
2282 VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0b00000000000000000010000000000000
2283 VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0b00000000000000000100000000000000
2284 VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0b00000000000000001000000000000000
2285 VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM = 0b00000000000000010000000000000000
2286 VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM = 0b00000000000000100000000000000000
2287 VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0b00000000000001000000000000000000
2288 VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0b00000000000010000000000000000000
2289 VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0b00000000000100000000000000000000
2290 VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0b00000000001000000000000000000000
2291 VK_IMAGE_USAGE_RESERVED_22_BIT_EXT = 0b00000000010000000000000000000000
2292 func toBits*(flags: openArray[VkImageUsageFlagBits]): VkImageUsageFlags =
2293 for flag in flags:
2294 result = VkImageUsageFlags(uint(result) or uint(flag))
2295 func toEnums*(number: VkImageUsageFlags): seq[VkImageUsageFlagBits] =
2296 for value in VkImageUsageFlagBits.items:
2297 if (value.ord and cint(number)) > 0:
2298 result.add value
2299 proc `==`*(a, b: VkImageUsageFlags): bool = cint(a) == cint(b)
2300 type
2301 VkImageCreateFlagBits* {.size: sizeof(cint).} = enum
2302 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0b00000000000000000000000000000001
2303 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0b00000000000000000000000000000010
2304 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0b00000000000000000000000000000100
2305 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0b00000000000000000000000000001000
2306 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0b00000000000000000000000000010000
2307 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0b00000000000000000000000000100000
2308 VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0b00000000000000000000000001000000
2309 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0b00000000000000000000000010000000
2310 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0b00000000000000000000000100000000
2311 VK_IMAGE_CREATE_DISJOINT_BIT = 0b00000000000000000000001000000000
2312 VK_IMAGE_CREATE_ALIAS_BIT = 0b00000000000000000000010000000000
2313 VK_IMAGE_CREATE_PROTECTED_BIT = 0b00000000000000000000100000000000
2314 VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0b00000000000000000001000000000000
2315 VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0b00000000000000000010000000000000
2316 VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0b00000000000000000100000000000000
2317 VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0b00000000000000001000000000000000
2318 VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000010000000000000000
2319 VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0b00000000000000100000000000000000
2320 VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0b00000000000001000000000000000000
2321 VK_IMAGE_CREATE_RESERVED_19_BIT_EXT = 0b00000000000010000000000000000000
2322 func toBits*(flags: openArray[VkImageCreateFlagBits]): VkImageCreateFlags =
2323 for flag in flags:
2324 result = VkImageCreateFlags(uint(result) or uint(flag))
2325 func toEnums*(number: VkImageCreateFlags): seq[VkImageCreateFlagBits] =
2326 for value in VkImageCreateFlagBits.items:
2327 if (value.ord and cint(number)) > 0:
2328 result.add value
2329 proc `==`*(a, b: VkImageCreateFlags): bool = cint(a) == cint(b)
2330 type
2331 VkImageViewCreateFlagBits* {.size: sizeof(cint).} = enum
2332 VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0b00000000000000000000000000000001
2333 VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0b00000000000000000000000000000010
2334 VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000000100
2335 func toBits*(flags: openArray[VkImageViewCreateFlagBits]): VkImageViewCreateFlags =
2336 for flag in flags:
2337 result = VkImageViewCreateFlags(uint(result) or uint(flag))
2338 func toEnums*(number: VkImageViewCreateFlags): seq[VkImageViewCreateFlagBits] =
2339 for value in VkImageViewCreateFlagBits.items:
2340 if (value.ord and cint(number)) > 0:
2341 result.add value
2342 proc `==`*(a, b: VkImageViewCreateFlags): bool = cint(a) == cint(b)
2343 type
2344 VkSamplerCreateFlagBits* {.size: sizeof(cint).} = enum
2345 VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0b00000000000000000000000000000001
2346 VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0b00000000000000000000000000000010
2347 VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0b00000000000000000000000000000100
2348 VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000001000
2349 VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0b00000000000000000000000000010000
2350 func toBits*(flags: openArray[VkSamplerCreateFlagBits]): VkSamplerCreateFlags =
2351 for flag in flags:
2352 result = VkSamplerCreateFlags(uint(result) or uint(flag))
2353 func toEnums*(number: VkSamplerCreateFlags): seq[VkSamplerCreateFlagBits] =
2354 for value in VkSamplerCreateFlagBits.items:
2355 if (value.ord and cint(number)) > 0:
2356 result.add value
2357 proc `==`*(a, b: VkSamplerCreateFlags): bool = cint(a) == cint(b)
2358 type
2359 VkPipelineCreateFlagBits* {.size: sizeof(cint).} = enum
2360 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0b00000000000000000000000000000001
2361 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0b00000000000000000000000000000010
2362 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0b00000000000000000000000000000100
2363 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0b00000000000000000000000000001000
2364 VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0b00000000000000000000000000010000
2365 VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0b00000000000000000000000000100000
2366 VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0b00000000000000000000000001000000
2367 VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0b00000000000000000000000010000000
2368 VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0b00000000000000000000000100000000
2369 VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0b00000000000000000000001000000000
2370 VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0b00000000000000000000010000000000
2371 VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0b00000000000000000000100000000000
2372 VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0b00000000000000000001000000000000
2373 VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0b00000000000000000010000000000000
2374 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0b00000000000000000100000000000000
2375 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0b00000000000000001000000000000000
2376 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0b00000000000000010000000000000000
2377 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0b00000000000000100000000000000000
2378 VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0b00000000000001000000000000000000
2379 VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0b00000000000010000000000000000000
2380 VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0b00000000000100000000000000000000
2381 VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b00000000001000000000000000000000
2382 VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0b00000000010000000000000000000000
2383 VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0b00000000100000000000000000000000
2384 VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0b00000001000000000000000000000000
2385 VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0b00000010000000000000000000000000
2386 VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0b00000100000000000000000000000000
2387 VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0b00001000000000000000000000000000
2388 VK_PIPELINE_CREATE_RESERVED_BIT_28_NV = 0b00010000000000000000000000000000
2389 VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0b00100000000000000000000000000000
2390 VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0b01000000000000000000000000000000
2391 func toBits*(flags: openArray[VkPipelineCreateFlagBits]): VkPipelineCreateFlags =
2392 for flag in flags:
2393 result = VkPipelineCreateFlags(uint(result) or uint(flag))
2394 func toEnums*(number: VkPipelineCreateFlags): seq[VkPipelineCreateFlagBits] =
2395 for value in VkPipelineCreateFlagBits.items:
2396 if (value.ord and cint(number)) > 0:
2397 result.add value
2398 proc `==`*(a, b: VkPipelineCreateFlags): bool = cint(a) == cint(b)
2399 type
2400 VkPipelineShaderStageCreateFlagBits* {.size: sizeof(cint).} = enum
2401 VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0b00000000000000000000000000000001
2402 VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0b00000000000000000000000000000010
2403 VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR = 0b00000000000000000000000000001000
2404 func toBits*(flags: openArray[VkPipelineShaderStageCreateFlagBits]): VkPipelineShaderStageCreateFlags =
2405 for flag in flags:
2406 result = VkPipelineShaderStageCreateFlags(uint(result) or uint(flag))
2407 func toEnums*(number: VkPipelineShaderStageCreateFlags): seq[VkPipelineShaderStageCreateFlagBits] =
2408 for value in VkPipelineShaderStageCreateFlagBits.items:
2409 if (value.ord and cint(number)) > 0:
2410 result.add value
2411 proc `==`*(a, b: VkPipelineShaderStageCreateFlags): bool = cint(a) == cint(b)
2412 type
2413 VkColorComponentFlagBits* {.size: sizeof(cint).} = enum
2414 VK_COLOR_COMPONENT_R_BIT = 0b00000000000000000000000000000001
2415 VK_COLOR_COMPONENT_G_BIT = 0b00000000000000000000000000000010
2416 VK_COLOR_COMPONENT_B_BIT = 0b00000000000000000000000000000100
2417 VK_COLOR_COMPONENT_A_BIT = 0b00000000000000000000000000001000
2418 func toBits*(flags: openArray[VkColorComponentFlagBits]): VkColorComponentFlags =
2419 for flag in flags:
2420 result = VkColorComponentFlags(uint(result) or uint(flag))
2421 func toEnums*(number: VkColorComponentFlags): seq[VkColorComponentFlagBits] =
2422 for value in VkColorComponentFlagBits.items:
2423 if (value.ord and cint(number)) > 0:
2424 result.add value
2425 proc `==`*(a, b: VkColorComponentFlags): bool = cint(a) == cint(b)
2426 type
2427 VkFenceCreateFlagBits* {.size: sizeof(cint).} = enum
2428 VK_FENCE_CREATE_SIGNALED_BIT = 0b00000000000000000000000000000001
2429 func toBits*(flags: openArray[VkFenceCreateFlagBits]): VkFenceCreateFlags =
2430 for flag in flags:
2431 result = VkFenceCreateFlags(uint(result) or uint(flag))
2432 func toEnums*(number: VkFenceCreateFlags): seq[VkFenceCreateFlagBits] =
2433 for value in VkFenceCreateFlagBits.items:
2434 if (value.ord and cint(number)) > 0:
2435 result.add value
2436 proc `==`*(a, b: VkFenceCreateFlags): bool = cint(a) == cint(b)
2437 type
2438 VkFormatFeatureFlagBits* {.size: sizeof(cint).} = enum
2439 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0b00000000000000000000000000000001
2440 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0b00000000000000000000000000000010
2441 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0b00000000000000000000000000000100
2442 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0b00000000000000000000000000001000
2443 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0b00000000000000000000000000010000
2444 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0b00000000000000000000000000100000
2445 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0b00000000000000000000000001000000
2446 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0b00000000000000000000000010000000
2447 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0b00000000000000000000000100000000
2448 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0b00000000000000000000001000000000
2449 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0b00000000000000000000010000000000
2450 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0b00000000000000000000100000000000
2451 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0b00000000000000000001000000000000
2452 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0b00000000000000000010000000000000
2453 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0b00000000000000000100000000000000
2454 VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0b00000000000000001000000000000000
2455 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0b00000000000000010000000000000000
2456 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0b00000000000000100000000000000000
2457 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0b00000000000001000000000000000000
2458 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0b00000000000010000000000000000000
2459 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0b00000000000100000000000000000000
2460 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0b00000000001000000000000000000000
2461 VK_FORMAT_FEATURE_DISJOINT_BIT = 0b00000000010000000000000000000000
2462 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0b00000000100000000000000000000000
2463 VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0b00000001000000000000000000000000
2464 VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0b00000010000000000000000000000000
2465 VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0b00000100000000000000000000000000
2466 VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0b00001000000000000000000000000000
2467 VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0b00010000000000000000000000000000
2468 VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0b00100000000000000000000000000000
2469 VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b01000000000000000000000000000000
2470 func toBits*(flags: openArray[VkFormatFeatureFlagBits]): VkFormatFeatureFlags =
2471 for flag in flags:
2472 result = VkFormatFeatureFlags(uint(result) or uint(flag))
2473 func toEnums*(number: VkFormatFeatureFlags): seq[VkFormatFeatureFlagBits] =
2474 for value in VkFormatFeatureFlagBits.items:
2475 if (value.ord and cint(number)) > 0:
2476 result.add value
2477 proc `==`*(a, b: VkFormatFeatureFlags): bool = cint(a) == cint(b)
2478 type
2479 VkQueryControlFlagBits* {.size: sizeof(cint).} = enum
2480 VK_QUERY_CONTROL_PRECISE_BIT = 0b00000000000000000000000000000001
2481 func toBits*(flags: openArray[VkQueryControlFlagBits]): VkQueryControlFlags =
2482 for flag in flags:
2483 result = VkQueryControlFlags(uint(result) or uint(flag))
2484 func toEnums*(number: VkQueryControlFlags): seq[VkQueryControlFlagBits] =
2485 for value in VkQueryControlFlagBits.items:
2486 if (value.ord and cint(number)) > 0:
2487 result.add value
2488 proc `==`*(a, b: VkQueryControlFlags): bool = cint(a) == cint(b)
2489 type
2490 VkQueryResultFlagBits* {.size: sizeof(cint).} = enum
2491 VK_QUERY_RESULT_64_BIT = 0b00000000000000000000000000000001
2492 VK_QUERY_RESULT_WAIT_BIT = 0b00000000000000000000000000000010
2493 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0b00000000000000000000000000000100
2494 VK_QUERY_RESULT_PARTIAL_BIT = 0b00000000000000000000000000001000
2495 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0b00000000000000000000000000010000
2496 func toBits*(flags: openArray[VkQueryResultFlagBits]): VkQueryResultFlags =
2497 for flag in flags:
2498 result = VkQueryResultFlags(uint(result) or uint(flag))
2499 func toEnums*(number: VkQueryResultFlags): seq[VkQueryResultFlagBits] =
2500 for value in VkQueryResultFlagBits.items:
2501 if (value.ord and cint(number)) > 0:
2502 result.add value
2503 proc `==`*(a, b: VkQueryResultFlags): bool = cint(a) == cint(b)
2504 type
2505 VkCommandBufferUsageFlagBits* {.size: sizeof(cint).} = enum
2506 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0b00000000000000000000000000000001
2507 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0b00000000000000000000000000000010
2508 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0b00000000000000000000000000000100
2509 func toBits*(flags: openArray[VkCommandBufferUsageFlagBits]): VkCommandBufferUsageFlags =
2510 for flag in flags:
2511 result = VkCommandBufferUsageFlags(uint(result) or uint(flag))
2512 func toEnums*(number: VkCommandBufferUsageFlags): seq[VkCommandBufferUsageFlagBits] =
2513 for value in VkCommandBufferUsageFlagBits.items:
2514 if (value.ord and cint(number)) > 0:
2515 result.add value
2516 proc `==`*(a, b: VkCommandBufferUsageFlags): bool = cint(a) == cint(b)
2517 type
2518 VkQueryPipelineStatisticFlagBits* {.size: sizeof(cint).} = enum
2519 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0b00000000000000000000000000000001
2520 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0b00000000000000000000000000000010
2521 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0b00000000000000000000000000000100
2522 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0b00000000000000000000000000001000
2523 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0b00000000000000000000000000010000
2524 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0b00000000000000000000000000100000
2525 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0b00000000000000000000000001000000
2526 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0b00000000000000000000000010000000
2527 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0b00000000000000000000000100000000
2528 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0b00000000000000000000001000000000
2529 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0b00000000000000000000010000000000
2530 VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0b00000000000000000000100000000000
2531 VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0b00000000000000000001000000000000
2532 VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0b00000000000000000010000000000000
2533 func toBits*(flags: openArray[VkQueryPipelineStatisticFlagBits]): VkQueryPipelineStatisticFlags =
2534 for flag in flags:
2535 result = VkQueryPipelineStatisticFlags(uint(result) or uint(flag))
2536 func toEnums*(number: VkQueryPipelineStatisticFlags): seq[VkQueryPipelineStatisticFlagBits] =
2537 for value in VkQueryPipelineStatisticFlagBits.items:
2538 if (value.ord and cint(number)) > 0:
2539 result.add value
2540 proc `==`*(a, b: VkQueryPipelineStatisticFlags): bool = cint(a) == cint(b)
2541 type
2542 VkImageAspectFlagBits* {.size: sizeof(cint).} = enum
2543 VK_IMAGE_ASPECT_COLOR_BIT = 0b00000000000000000000000000000001
2544 VK_IMAGE_ASPECT_DEPTH_BIT = 0b00000000000000000000000000000010
2545 VK_IMAGE_ASPECT_STENCIL_BIT = 0b00000000000000000000000000000100
2546 VK_IMAGE_ASPECT_METADATA_BIT = 0b00000000000000000000000000001000
2547 VK_IMAGE_ASPECT_PLANE_0_BIT = 0b00000000000000000000000000010000
2548 VK_IMAGE_ASPECT_PLANE_1_BIT = 0b00000000000000000000000000100000
2549 VK_IMAGE_ASPECT_PLANE_2_BIT = 0b00000000000000000000000001000000
2550 VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0b00000000000000000000000010000000
2551 VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0b00000000000000000000000100000000
2552 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0b00000000000000000000001000000000
2553 VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0b00000000000000000000010000000000
2554 func toBits*(flags: openArray[VkImageAspectFlagBits]): VkImageAspectFlags =
2555 for flag in flags:
2556 result = VkImageAspectFlags(uint(result) or uint(flag))
2557 func toEnums*(number: VkImageAspectFlags): seq[VkImageAspectFlagBits] =
2558 for value in VkImageAspectFlagBits.items:
2559 if (value.ord and cint(number)) > 0:
2560 result.add value
2561 proc `==`*(a, b: VkImageAspectFlags): bool = cint(a) == cint(b)
2562 type
2563 VkSparseImageFormatFlagBits* {.size: sizeof(cint).} = enum
2564 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0b00000000000000000000000000000001
2565 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0b00000000000000000000000000000010
2566 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0b00000000000000000000000000000100
2567 func toBits*(flags: openArray[VkSparseImageFormatFlagBits]): VkSparseImageFormatFlags =
2568 for flag in flags:
2569 result = VkSparseImageFormatFlags(uint(result) or uint(flag))
2570 func toEnums*(number: VkSparseImageFormatFlags): seq[VkSparseImageFormatFlagBits] =
2571 for value in VkSparseImageFormatFlagBits.items:
2572 if (value.ord and cint(number)) > 0:
2573 result.add value
2574 proc `==`*(a, b: VkSparseImageFormatFlags): bool = cint(a) == cint(b)
2575 type
2576 VkSparseMemoryBindFlagBits* {.size: sizeof(cint).} = enum
2577 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0b00000000000000000000000000000001
2578 func toBits*(flags: openArray[VkSparseMemoryBindFlagBits]): VkSparseMemoryBindFlags =
2579 for flag in flags:
2580 result = VkSparseMemoryBindFlags(uint(result) or uint(flag))
2581 func toEnums*(number: VkSparseMemoryBindFlags): seq[VkSparseMemoryBindFlagBits] =
2582 for value in VkSparseMemoryBindFlagBits.items:
2583 if (value.ord and cint(number)) > 0:
2584 result.add value
2585 proc `==`*(a, b: VkSparseMemoryBindFlags): bool = cint(a) == cint(b)
2586 type
2587 VkPipelineStageFlagBits* {.size: sizeof(cint).} = enum
2588 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0b00000000000000000000000000000001
2589 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0b00000000000000000000000000000010
2590 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0b00000000000000000000000000000100
2591 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0b00000000000000000000000000001000
2592 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0b00000000000000000000000000010000
2593 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0b00000000000000000000000000100000
2594 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0b00000000000000000000000001000000
2595 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0b00000000000000000000000010000000
2596 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0b00000000000000000000000100000000
2597 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0b00000000000000000000001000000000
2598 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0b00000000000000000000010000000000
2599 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0b00000000000000000000100000000000
2600 VK_PIPELINE_STAGE_TRANSFER_BIT = 0b00000000000000000001000000000000
2601 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0b00000000000000000010000000000000
2602 VK_PIPELINE_STAGE_HOST_BIT = 0b00000000000000000100000000000000
2603 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0b00000000000000001000000000000000
2604 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0b00000000000000010000000000000000
2605 VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0b00000000000000100000000000000000
2606 VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0b00000000000001000000000000000000
2607 VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0b00000000000010000000000000000000
2608 VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0b00000000000100000000000000000000
2609 VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0b00000000001000000000000000000000
2610 VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b00000000010000000000000000000000
2611 VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0b00000000100000000000000000000000
2612 VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0b00000001000000000000000000000000
2613 VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0b00000010000000000000000000000000
2614 func toBits*(flags: openArray[VkPipelineStageFlagBits]): VkPipelineStageFlags =
2615 for flag in flags:
2616 result = VkPipelineStageFlags(uint(result) or uint(flag))
2617 func toEnums*(number: VkPipelineStageFlags): seq[VkPipelineStageFlagBits] =
2618 for value in VkPipelineStageFlagBits.items:
2619 if (value.ord and cint(number)) > 0:
2620 result.add value
2621 proc `==`*(a, b: VkPipelineStageFlags): bool = cint(a) == cint(b)
2622 type
2623 VkCommandPoolCreateFlagBits* {.size: sizeof(cint).} = enum
2624 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0b00000000000000000000000000000001
2625 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0b00000000000000000000000000000010
2626 VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0b00000000000000000000000000000100
2627 func toBits*(flags: openArray[VkCommandPoolCreateFlagBits]): VkCommandPoolCreateFlags =
2628 for flag in flags:
2629 result = VkCommandPoolCreateFlags(uint(result) or uint(flag))
2630 func toEnums*(number: VkCommandPoolCreateFlags): seq[VkCommandPoolCreateFlagBits] =
2631 for value in VkCommandPoolCreateFlagBits.items:
2632 if (value.ord and cint(number)) > 0:
2633 result.add value
2634 proc `==`*(a, b: VkCommandPoolCreateFlags): bool = cint(a) == cint(b)
2635 type
2636 VkCommandPoolResetFlagBits* {.size: sizeof(cint).} = enum
2637 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0b00000000000000000000000000000001
2638 VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI = 0b00000000000000000000000000000010
2639 func toBits*(flags: openArray[VkCommandPoolResetFlagBits]): VkCommandPoolResetFlags =
2640 for flag in flags:
2641 result = VkCommandPoolResetFlags(uint(result) or uint(flag))
2642 func toEnums*(number: VkCommandPoolResetFlags): seq[VkCommandPoolResetFlagBits] =
2643 for value in VkCommandPoolResetFlagBits.items:
2644 if (value.ord and cint(number)) > 0:
2645 result.add value
2646 proc `==`*(a, b: VkCommandPoolResetFlags): bool = cint(a) == cint(b)
2647 type
2648 VkCommandBufferResetFlagBits* {.size: sizeof(cint).} = enum
2649 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0b00000000000000000000000000000001
2650 func toBits*(flags: openArray[VkCommandBufferResetFlagBits]): VkCommandBufferResetFlags =
2651 for flag in flags:
2652 result = VkCommandBufferResetFlags(uint(result) or uint(flag))
2653 func toEnums*(number: VkCommandBufferResetFlags): seq[VkCommandBufferResetFlagBits] =
2654 for value in VkCommandBufferResetFlagBits.items:
2655 if (value.ord and cint(number)) > 0:
2656 result.add value
2657 proc `==`*(a, b: VkCommandBufferResetFlags): bool = cint(a) == cint(b)
2658 type
2659 VkSampleCountFlagBits* {.size: sizeof(cint).} = enum
2660 VK_SAMPLE_COUNT_1_BIT = 0b00000000000000000000000000000001
2661 VK_SAMPLE_COUNT_2_BIT = 0b00000000000000000000000000000010
2662 VK_SAMPLE_COUNT_4_BIT = 0b00000000000000000000000000000100
2663 VK_SAMPLE_COUNT_8_BIT = 0b00000000000000000000000000001000
2664 VK_SAMPLE_COUNT_16_BIT = 0b00000000000000000000000000010000
2665 VK_SAMPLE_COUNT_32_BIT = 0b00000000000000000000000000100000
2666 VK_SAMPLE_COUNT_64_BIT = 0b00000000000000000000000001000000
2667 func toBits*(flags: openArray[VkSampleCountFlagBits]): VkSampleCountFlags =
2668 for flag in flags:
2669 result = VkSampleCountFlags(uint(result) or uint(flag))
2670 func toEnums*(number: VkSampleCountFlags): seq[VkSampleCountFlagBits] =
2671 for value in VkSampleCountFlagBits.items:
2672 if (value.ord and cint(number)) > 0:
2673 result.add value
2674 proc `==`*(a, b: VkSampleCountFlags): bool = cint(a) == cint(b)
2675 type
2676 VkAttachmentDescriptionFlagBits* {.size: sizeof(cint).} = enum
2677 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0b00000000000000000000000000000001
2678 func toBits*(flags: openArray[VkAttachmentDescriptionFlagBits]): VkAttachmentDescriptionFlags =
2679 for flag in flags:
2680 result = VkAttachmentDescriptionFlags(uint(result) or uint(flag))
2681 func toEnums*(number: VkAttachmentDescriptionFlags): seq[VkAttachmentDescriptionFlagBits] =
2682 for value in VkAttachmentDescriptionFlagBits.items:
2683 if (value.ord and cint(number)) > 0:
2684 result.add value
2685 proc `==`*(a, b: VkAttachmentDescriptionFlags): bool = cint(a) == cint(b)
2686 type
2687 VkStencilFaceFlagBits* {.size: sizeof(cint).} = enum
2688 VK_STENCIL_FACE_FRONT_BIT = 0b00000000000000000000000000000001
2689 VK_STENCIL_FACE_BACK_BIT = 0b00000000000000000000000000000010
2690 func toBits*(flags: openArray[VkStencilFaceFlagBits]): VkStencilFaceFlags =
2691 for flag in flags:
2692 result = VkStencilFaceFlags(uint(result) or uint(flag))
2693 func toEnums*(number: VkStencilFaceFlags): seq[VkStencilFaceFlagBits] =
2694 for value in VkStencilFaceFlagBits.items:
2695 if (value.ord and cint(number)) > 0:
2696 result.add value
2697 proc `==`*(a, b: VkStencilFaceFlags): bool = cint(a) == cint(b)
2698 const
2699 VK_STENCIL_FACE_FRONT_AND_BACK* = 0x00000003
2700 type
2701 VkDescriptorPoolCreateFlagBits* {.size: sizeof(cint).} = enum
2702 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0b00000000000000000000000000000001
2703 VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0b00000000000000000000000000000010
2704 VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0b00000000000000000000000000000100
2705 func toBits*(flags: openArray[VkDescriptorPoolCreateFlagBits]): VkDescriptorPoolCreateFlags =
2706 for flag in flags:
2707 result = VkDescriptorPoolCreateFlags(uint(result) or uint(flag))
2708 func toEnums*(number: VkDescriptorPoolCreateFlags): seq[VkDescriptorPoolCreateFlagBits] =
2709 for value in VkDescriptorPoolCreateFlagBits.items:
2710 if (value.ord and cint(number)) > 0:
2711 result.add value
2712 proc `==`*(a, b: VkDescriptorPoolCreateFlags): bool = cint(a) == cint(b)
2713 type
2714 VkDependencyFlagBits* {.size: sizeof(cint).} = enum
2715 VK_DEPENDENCY_BY_REGION_BIT = 0b00000000000000000000000000000001
2716 VK_DEPENDENCY_VIEW_LOCAL_BIT = 0b00000000000000000000000000000010
2717 VK_DEPENDENCY_DEVICE_GROUP_BIT = 0b00000000000000000000000000000100
2718 VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0b00000000000000000000000000001000
2719 func toBits*(flags: openArray[VkDependencyFlagBits]): VkDependencyFlags =
2720 for flag in flags:
2721 result = VkDependencyFlags(uint(result) or uint(flag))
2722 func toEnums*(number: VkDependencyFlags): seq[VkDependencyFlagBits] =
2723 for value in VkDependencyFlagBits.items:
2724 if (value.ord and cint(number)) > 0:
2725 result.add value
2726 proc `==`*(a, b: VkDependencyFlags): bool = cint(a) == cint(b)
2727 type
2728 VkSemaphoreType* {.size: sizeof(cint).} = enum
2729 VK_SEMAPHORE_TYPE_BINARY = 0
2730 VK_SEMAPHORE_TYPE_TIMELINE = 1
2731 VkSemaphoreWaitFlagBits* {.size: sizeof(cint).} = enum
2732 VK_SEMAPHORE_WAIT_ANY_BIT = 0b00000000000000000000000000000001
2733 func toBits*(flags: openArray[VkSemaphoreWaitFlagBits]): VkSemaphoreWaitFlags =
2734 for flag in flags:
2735 result = VkSemaphoreWaitFlags(uint(result) or uint(flag))
2736 func toEnums*(number: VkSemaphoreWaitFlags): seq[VkSemaphoreWaitFlagBits] =
2737 for value in VkSemaphoreWaitFlagBits.items:
2738 if (value.ord and cint(number)) > 0:
2739 result.add value
2740 proc `==`*(a, b: VkSemaphoreWaitFlags): bool = cint(a) == cint(b)
2741 type
2742 VkPresentModeKHR* {.size: sizeof(cint).} = enum
2743 VK_PRESENT_MODE_IMMEDIATE_KHR = 0
2744 VK_PRESENT_MODE_MAILBOX_KHR = 1
2745 VK_PRESENT_MODE_FIFO_KHR = 2
2746 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3
2747 VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000
2748 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001
2749 VkColorSpaceKHR* {.size: sizeof(cint).} = enum
2750 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0
2751 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001
2752 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002
2753 VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003
2754 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004
2755 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005
2756 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006
2757 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007
2758 VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008
2759 VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009
2760 VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010
2761 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011
2762 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012
2763 VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013
2764 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014
2765 VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000
2766 VkDisplayPlaneAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum
2767 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0b00000000000000000000000000000001
2768 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0b00000000000000000000000000000010
2769 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0b00000000000000000000000000000100
2770 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0b00000000000000000000000000001000
2771 func toBits*(flags: openArray[VkDisplayPlaneAlphaFlagBitsKHR]): VkDisplayPlaneAlphaFlagsKHR =
2772 for flag in flags:
2773 result = VkDisplayPlaneAlphaFlagsKHR(uint(result) or uint(flag))
2774 func toEnums*(number: VkDisplayPlaneAlphaFlagsKHR): seq[VkDisplayPlaneAlphaFlagBitsKHR] =
2775 for value in VkDisplayPlaneAlphaFlagBitsKHR.items:
2776 if (value.ord and cint(number)) > 0:
2777 result.add value
2778 proc `==`*(a, b: VkDisplayPlaneAlphaFlagsKHR): bool = cint(a) == cint(b)
2779 type
2780 VkCompositeAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum
2781 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0b00000000000000000000000000000001
2782 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0b00000000000000000000000000000010
2783 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0b00000000000000000000000000000100
2784 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0b00000000000000000000000000001000
2785 func toBits*(flags: openArray[VkCompositeAlphaFlagBitsKHR]): VkCompositeAlphaFlagsKHR =
2786 for flag in flags:
2787 result = VkCompositeAlphaFlagsKHR(uint(result) or uint(flag))
2788 func toEnums*(number: VkCompositeAlphaFlagsKHR): seq[VkCompositeAlphaFlagBitsKHR] =
2789 for value in VkCompositeAlphaFlagBitsKHR.items:
2790 if (value.ord and cint(number)) > 0:
2791 result.add value
2792 proc `==`*(a, b: VkCompositeAlphaFlagsKHR): bool = cint(a) == cint(b)
2793 type
2794 VkSurfaceTransformFlagBitsKHR* {.size: sizeof(cint).} = enum
2795 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0b00000000000000000000000000000001
2796 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0b00000000000000000000000000000010
2797 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0b00000000000000000000000000000100
2798 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0b00000000000000000000000000001000
2799 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0b00000000000000000000000000010000
2800 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0b00000000000000000000000000100000
2801 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0b00000000000000000000000001000000
2802 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0b00000000000000000000000010000000
2803 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0b00000000000000000000000100000000
2804 func toBits*(flags: openArray[VkSurfaceTransformFlagBitsKHR]): VkSurfaceTransformFlagsKHR =
2805 for flag in flags:
2806 result = VkSurfaceTransformFlagsKHR(uint(result) or uint(flag))
2807 func toEnums*(number: VkSurfaceTransformFlagsKHR): seq[VkSurfaceTransformFlagBitsKHR] =
2808 for value in VkSurfaceTransformFlagBitsKHR.items:
2809 if (value.ord and cint(number)) > 0:
2810 result.add value
2811 proc `==`*(a, b: VkSurfaceTransformFlagsKHR): bool = cint(a) == cint(b)
2812 type
2813 VkSwapchainImageUsageFlagBitsANDROID* {.size: sizeof(cint).} = enum
2814 VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0b00000000000000000000000000000001
2815 func toBits*(flags: openArray[VkSwapchainImageUsageFlagBitsANDROID]): VkSwapchainImageUsageFlagsANDROID =
2816 for flag in flags:
2817 result = VkSwapchainImageUsageFlagsANDROID(uint(result) or uint(flag))
2818 func toEnums*(number: VkSwapchainImageUsageFlagsANDROID): seq[VkSwapchainImageUsageFlagBitsANDROID] =
2819 for value in VkSwapchainImageUsageFlagBitsANDROID.items:
2820 if (value.ord and cint(number)) > 0:
2821 result.add value
2822 proc `==`*(a, b: VkSwapchainImageUsageFlagsANDROID): bool = cint(a) == cint(b)
2823 type
2824 VkTimeDomainEXT* {.size: sizeof(cint).} = enum
2825 VK_TIME_DOMAIN_DEVICE_EXT = 0
2826 VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1
2827 VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2
2828 VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3
2829 VkDebugReportFlagBitsEXT* {.size: sizeof(cint).} = enum
2830 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0b00000000000000000000000000000001
2831 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0b00000000000000000000000000000010
2832 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0b00000000000000000000000000000100
2833 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0b00000000000000000000000000001000
2834 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0b00000000000000000000000000010000
2835 func toBits*(flags: openArray[VkDebugReportFlagBitsEXT]): VkDebugReportFlagsEXT =
2836 for flag in flags:
2837 result = VkDebugReportFlagsEXT(uint(result) or uint(flag))
2838 func toEnums*(number: VkDebugReportFlagsEXT): seq[VkDebugReportFlagBitsEXT] =
2839 for value in VkDebugReportFlagBitsEXT.items:
2840 if (value.ord and cint(number)) > 0:
2841 result.add value
2842 proc `==`*(a, b: VkDebugReportFlagsEXT): bool = cint(a) == cint(b)
2843 type
2844 VkDebugReportObjectTypeEXT* {.size: sizeof(cint).} = enum
2845 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0
2846 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1
2847 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2
2848 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3
2849 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4
2850 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5
2851 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6
2852 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7
2853 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8
2854 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9
2855 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10
2856 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11
2857 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12
2858 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13
2859 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14
2860 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15
2861 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16
2862 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17
2863 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18
2864 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19
2865 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20
2866 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21
2867 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22
2868 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23
2869 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24
2870 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25
2871 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26
2872 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27
2873 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28
2874 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29
2875 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30
2876 VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33
2877 VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000
2878 VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001
2879 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000
2880 VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000
2881 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000
2882 VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000
2883 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000
2884 VkDeviceMemoryReportEventTypeEXT* {.size: sizeof(cint).} = enum
2885 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0
2886 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1
2887 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2
2888 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3
2889 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4
2890 VkRasterizationOrderAMD* {.size: sizeof(cint).} = enum
2891 VK_RASTERIZATION_ORDER_STRICT_AMD = 0
2892 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1
2893 VkExternalMemoryHandleTypeFlagBitsNV* {.size: sizeof(cint).} = enum
2894 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0b00000000000000000000000000000001
2895 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0b00000000000000000000000000000010
2896 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0b00000000000000000000000000000100
2897 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0b00000000000000000000000000001000
2898 func toBits*(flags: openArray[VkExternalMemoryHandleTypeFlagBitsNV]): VkExternalMemoryHandleTypeFlagsNV =
2899 for flag in flags:
2900 result = VkExternalMemoryHandleTypeFlagsNV(uint(result) or uint(flag))
2901 func toEnums*(number: VkExternalMemoryHandleTypeFlagsNV): seq[VkExternalMemoryHandleTypeFlagBitsNV] =
2902 for value in VkExternalMemoryHandleTypeFlagBitsNV.items:
2903 if (value.ord and cint(number)) > 0:
2904 result.add value
2905 proc `==`*(a, b: VkExternalMemoryHandleTypeFlagsNV): bool = cint(a) == cint(b)
2906 type
2907 VkExternalMemoryFeatureFlagBitsNV* {.size: sizeof(cint).} = enum
2908 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0b00000000000000000000000000000001
2909 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0b00000000000000000000000000000010
2910 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0b00000000000000000000000000000100
2911 func toBits*(flags: openArray[VkExternalMemoryFeatureFlagBitsNV]): VkExternalMemoryFeatureFlagsNV =
2912 for flag in flags:
2913 result = VkExternalMemoryFeatureFlagsNV(uint(result) or uint(flag))
2914 func toEnums*(number: VkExternalMemoryFeatureFlagsNV): seq[VkExternalMemoryFeatureFlagBitsNV] =
2915 for value in VkExternalMemoryFeatureFlagBitsNV.items:
2916 if (value.ord and cint(number)) > 0:
2917 result.add value
2918 proc `==`*(a, b: VkExternalMemoryFeatureFlagsNV): bool = cint(a) == cint(b)
2919 type
2920 VkValidationCheckEXT* {.size: sizeof(cint).} = enum
2921 VK_VALIDATION_CHECK_ALL_EXT = 0
2922 VK_VALIDATION_CHECK_SHADERS_EXT = 1
2923 VkValidationFeatureEnableEXT* {.size: sizeof(cint).} = enum
2924 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0
2925 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1
2926 VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2
2927 VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3
2928 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4
2929 VkValidationFeatureDisableEXT* {.size: sizeof(cint).} = enum
2930 VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0
2931 VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1
2932 VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2
2933 VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3
2934 VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4
2935 VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5
2936 VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6
2937 VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7
2938 VkSubgroupFeatureFlagBits* {.size: sizeof(cint).} = enum
2939 VK_SUBGROUP_FEATURE_BASIC_BIT = 0b00000000000000000000000000000001
2940 VK_SUBGROUP_FEATURE_VOTE_BIT = 0b00000000000000000000000000000010
2941 VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0b00000000000000000000000000000100
2942 VK_SUBGROUP_FEATURE_BALLOT_BIT = 0b00000000000000000000000000001000
2943 VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0b00000000000000000000000000010000
2944 VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0b00000000000000000000000000100000
2945 VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0b00000000000000000000000001000000
2946 VK_SUBGROUP_FEATURE_QUAD_BIT = 0b00000000000000000000000010000000
2947 VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0b00000000000000000000000100000000
2948 func toBits*(flags: openArray[VkSubgroupFeatureFlagBits]): VkSubgroupFeatureFlags =
2949 for flag in flags:
2950 result = VkSubgroupFeatureFlags(uint(result) or uint(flag))
2951 func toEnums*(number: VkSubgroupFeatureFlags): seq[VkSubgroupFeatureFlagBits] =
2952 for value in VkSubgroupFeatureFlagBits.items:
2953 if (value.ord and cint(number)) > 0:
2954 result.add value
2955 proc `==`*(a, b: VkSubgroupFeatureFlags): bool = cint(a) == cint(b)
2956 type
2957 VkIndirectCommandsLayoutUsageFlagBitsNV* {.size: sizeof(cint).} = enum
2958 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0b00000000000000000000000000000001
2959 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0b00000000000000000000000000000010
2960 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0b00000000000000000000000000000100
2961 func toBits*(flags: openArray[VkIndirectCommandsLayoutUsageFlagBitsNV]): VkIndirectCommandsLayoutUsageFlagsNV =
2962 for flag in flags:
2963 result = VkIndirectCommandsLayoutUsageFlagsNV(uint(result) or uint(flag))
2964 func toEnums*(number: VkIndirectCommandsLayoutUsageFlagsNV): seq[VkIndirectCommandsLayoutUsageFlagBitsNV] =
2965 for value in VkIndirectCommandsLayoutUsageFlagBitsNV.items:
2966 if (value.ord and cint(number)) > 0:
2967 result.add value
2968 proc `==`*(a, b: VkIndirectCommandsLayoutUsageFlagsNV): bool = cint(a) == cint(b)
2969 type
2970 VkIndirectStateFlagBitsNV* {.size: sizeof(cint).} = enum
2971 VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0b00000000000000000000000000000001
2972 func toBits*(flags: openArray[VkIndirectStateFlagBitsNV]): VkIndirectStateFlagsNV =
2973 for flag in flags:
2974 result = VkIndirectStateFlagsNV(uint(result) or uint(flag))
2975 func toEnums*(number: VkIndirectStateFlagsNV): seq[VkIndirectStateFlagBitsNV] =
2976 for value in VkIndirectStateFlagBitsNV.items:
2977 if (value.ord and cint(number)) > 0:
2978 result.add value
2979 proc `==`*(a, b: VkIndirectStateFlagsNV): bool = cint(a) == cint(b)
2980 type
2981 VkIndirectCommandsTokenTypeNV* {.size: sizeof(cint).} = enum
2982 VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0
2983 VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1
2984 VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2
2985 VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3
2986 VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4
2987 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5
2988 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6
2989 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7
2990 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000
2991 VkPrivateDataSlotCreateFlagBits* {.size: sizeof(cint).} = enum
2992 VK_PRIVATE_DATA_SLOT_CREATE_RESERVED_0_BIT_NV = 0b00000000000000000000000000000001
2993 func toBits*(flags: openArray[VkPrivateDataSlotCreateFlagBits]): VkPrivateDataSlotCreateFlags =
2994 for flag in flags:
2995 result = VkPrivateDataSlotCreateFlags(uint(result) or uint(flag))
2996 func toEnums*(number: VkPrivateDataSlotCreateFlags): seq[VkPrivateDataSlotCreateFlagBits] =
2997 for value in VkPrivateDataSlotCreateFlagBits.items:
2998 if (value.ord and cint(number)) > 0:
2999 result.add value
3000 proc `==`*(a, b: VkPrivateDataSlotCreateFlags): bool = cint(a) == cint(b)
3001 type
3002 VkDescriptorSetLayoutCreateFlagBits* {.size: sizeof(cint).} = enum
3003 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0b00000000000000000000000000000001
3004 VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0b00000000000000000000000000000010
3005 VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0b00000000000000000000000000000100
3006 VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD = 0b00000000000000000000000000001000
3007 VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000000000000000000000000010000
3008 VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0b00000000000000000000000000100000
3009 func toBits*(flags: openArray[VkDescriptorSetLayoutCreateFlagBits]): VkDescriptorSetLayoutCreateFlags =
3010 for flag in flags:
3011 result = VkDescriptorSetLayoutCreateFlags(uint(result) or uint(flag))
3012 func toEnums*(number: VkDescriptorSetLayoutCreateFlags): seq[VkDescriptorSetLayoutCreateFlagBits] =
3013 for value in VkDescriptorSetLayoutCreateFlagBits.items:
3014 if (value.ord and cint(number)) > 0:
3015 result.add value
3016 proc `==`*(a, b: VkDescriptorSetLayoutCreateFlags): bool = cint(a) == cint(b)
3017 type
3018 VkExternalMemoryHandleTypeFlagBits* {.size: sizeof(cint).} = enum
3019 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0b00000000000000000000000000000001
3020 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0b00000000000000000000000000000010
3021 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0b00000000000000000000000000000100
3022 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0b00000000000000000000000000001000
3023 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0b00000000000000000000000000010000
3024 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0b00000000000000000000000000100000
3025 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0b00000000000000000000000001000000
3026 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0b00000000000000000000000010000000
3027 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0b00000000000000000000000100000000
3028 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0b00000000000000000000001000000000
3029 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0b00000000000000000000010000000000
3030 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0b00000000000000000000100000000000
3031 VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0b00000000000000000001000000000000
3032 VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV = 0b00000000000000000010000000000000
3033 func toBits*(flags: openArray[VkExternalMemoryHandleTypeFlagBits]): VkExternalMemoryHandleTypeFlags =
3034 for flag in flags:
3035 result = VkExternalMemoryHandleTypeFlags(uint(result) or uint(flag))
3036 func toEnums*(number: VkExternalMemoryHandleTypeFlags): seq[VkExternalMemoryHandleTypeFlagBits] =
3037 for value in VkExternalMemoryHandleTypeFlagBits.items:
3038 if (value.ord and cint(number)) > 0:
3039 result.add value
3040 proc `==`*(a, b: VkExternalMemoryHandleTypeFlags): bool = cint(a) == cint(b)
3041 type
3042 VkExternalMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum
3043 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0b00000000000000000000000000000001
3044 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0b00000000000000000000000000000010
3045 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0b00000000000000000000000000000100
3046 func toBits*(flags: openArray[VkExternalMemoryFeatureFlagBits]): VkExternalMemoryFeatureFlags =
3047 for flag in flags:
3048 result = VkExternalMemoryFeatureFlags(uint(result) or uint(flag))
3049 func toEnums*(number: VkExternalMemoryFeatureFlags): seq[VkExternalMemoryFeatureFlagBits] =
3050 for value in VkExternalMemoryFeatureFlagBits.items:
3051 if (value.ord and cint(number)) > 0:
3052 result.add value
3053 proc `==`*(a, b: VkExternalMemoryFeatureFlags): bool = cint(a) == cint(b)
3054 type
3055 VkExternalSemaphoreHandleTypeFlagBits* {.size: sizeof(cint).} = enum
3056 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0b00000000000000000000000000000001
3057 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0b00000000000000000000000000000010
3058 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0b00000000000000000000000000000100
3059 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0b00000000000000000000000000001000
3060 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0b00000000000000000000000000010000
3061 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV = 0b00000000000000000000000000100000
3062 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0b00000000000000000000000010000000
3063 func toBits*(flags: openArray[VkExternalSemaphoreHandleTypeFlagBits]): VkExternalSemaphoreHandleTypeFlags =
3064 for flag in flags:
3065 result = VkExternalSemaphoreHandleTypeFlags(uint(result) or uint(flag))
3066 func toEnums*(number: VkExternalSemaphoreHandleTypeFlags): seq[VkExternalSemaphoreHandleTypeFlagBits] =
3067 for value in VkExternalSemaphoreHandleTypeFlagBits.items:
3068 if (value.ord and cint(number)) > 0:
3069 result.add value
3070 proc `==`*(a, b: VkExternalSemaphoreHandleTypeFlags): bool = cint(a) == cint(b)
3071 type
3072 VkExternalSemaphoreFeatureFlagBits* {.size: sizeof(cint).} = enum
3073 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0b00000000000000000000000000000001
3074 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0b00000000000000000000000000000010
3075 func toBits*(flags: openArray[VkExternalSemaphoreFeatureFlagBits]): VkExternalSemaphoreFeatureFlags =
3076 for flag in flags:
3077 result = VkExternalSemaphoreFeatureFlags(uint(result) or uint(flag))
3078 func toEnums*(number: VkExternalSemaphoreFeatureFlags): seq[VkExternalSemaphoreFeatureFlagBits] =
3079 for value in VkExternalSemaphoreFeatureFlagBits.items:
3080 if (value.ord and cint(number)) > 0:
3081 result.add value
3082 proc `==`*(a, b: VkExternalSemaphoreFeatureFlags): bool = cint(a) == cint(b)
3083 type
3084 VkSemaphoreImportFlagBits* {.size: sizeof(cint).} = enum
3085 VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0b00000000000000000000000000000001
3086 func toBits*(flags: openArray[VkSemaphoreImportFlagBits]): VkSemaphoreImportFlags =
3087 for flag in flags:
3088 result = VkSemaphoreImportFlags(uint(result) or uint(flag))
3089 func toEnums*(number: VkSemaphoreImportFlags): seq[VkSemaphoreImportFlagBits] =
3090 for value in VkSemaphoreImportFlagBits.items:
3091 if (value.ord and cint(number)) > 0:
3092 result.add value
3093 proc `==`*(a, b: VkSemaphoreImportFlags): bool = cint(a) == cint(b)
3094 type
3095 VkExternalFenceHandleTypeFlagBits* {.size: sizeof(cint).} = enum
3096 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0b00000000000000000000000000000001
3097 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0b00000000000000000000000000000010
3098 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0b00000000000000000000000000000100
3099 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0b00000000000000000000000000001000
3100 VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV = 0b00000000000000000000000000010000
3101 VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV = 0b00000000000000000000000000100000
3102 func toBits*(flags: openArray[VkExternalFenceHandleTypeFlagBits]): VkExternalFenceHandleTypeFlags =
3103 for flag in flags:
3104 result = VkExternalFenceHandleTypeFlags(uint(result) or uint(flag))
3105 func toEnums*(number: VkExternalFenceHandleTypeFlags): seq[VkExternalFenceHandleTypeFlagBits] =
3106 for value in VkExternalFenceHandleTypeFlagBits.items:
3107 if (value.ord and cint(number)) > 0:
3108 result.add value
3109 proc `==`*(a, b: VkExternalFenceHandleTypeFlags): bool = cint(a) == cint(b)
3110 type
3111 VkExternalFenceFeatureFlagBits* {.size: sizeof(cint).} = enum
3112 VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0b00000000000000000000000000000001
3113 VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0b00000000000000000000000000000010
3114 func toBits*(flags: openArray[VkExternalFenceFeatureFlagBits]): VkExternalFenceFeatureFlags =
3115 for flag in flags:
3116 result = VkExternalFenceFeatureFlags(uint(result) or uint(flag))
3117 func toEnums*(number: VkExternalFenceFeatureFlags): seq[VkExternalFenceFeatureFlagBits] =
3118 for value in VkExternalFenceFeatureFlagBits.items:
3119 if (value.ord and cint(number)) > 0:
3120 result.add value
3121 proc `==`*(a, b: VkExternalFenceFeatureFlags): bool = cint(a) == cint(b)
3122 type
3123 VkFenceImportFlagBits* {.size: sizeof(cint).} = enum
3124 VK_FENCE_IMPORT_TEMPORARY_BIT = 0b00000000000000000000000000000001
3125 func toBits*(flags: openArray[VkFenceImportFlagBits]): VkFenceImportFlags =
3126 for flag in flags:
3127 result = VkFenceImportFlags(uint(result) or uint(flag))
3128 func toEnums*(number: VkFenceImportFlags): seq[VkFenceImportFlagBits] =
3129 for value in VkFenceImportFlagBits.items:
3130 if (value.ord and cint(number)) > 0:
3131 result.add value
3132 proc `==`*(a, b: VkFenceImportFlags): bool = cint(a) == cint(b)
3133 type
3134 VkSurfaceCounterFlagBitsEXT* {.size: sizeof(cint).} = enum
3135 VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0b00000000000000000000000000000001
3136 func toBits*(flags: openArray[VkSurfaceCounterFlagBitsEXT]): VkSurfaceCounterFlagsEXT =
3137 for flag in flags:
3138 result = VkSurfaceCounterFlagsEXT(uint(result) or uint(flag))
3139 func toEnums*(number: VkSurfaceCounterFlagsEXT): seq[VkSurfaceCounterFlagBitsEXT] =
3140 for value in VkSurfaceCounterFlagBitsEXT.items:
3141 if (value.ord and cint(number)) > 0:
3142 result.add value
3143 proc `==`*(a, b: VkSurfaceCounterFlagsEXT): bool = cint(a) == cint(b)
3144 type
3145 VkDisplayPowerStateEXT* {.size: sizeof(cint).} = enum
3146 VK_DISPLAY_POWER_STATE_OFF_EXT = 0
3147 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1
3148 VK_DISPLAY_POWER_STATE_ON_EXT = 2
3149 VkDeviceEventTypeEXT* {.size: sizeof(cint).} = enum
3150 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0
3151 VkDisplayEventTypeEXT* {.size: sizeof(cint).} = enum
3152 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0
3153 VkPeerMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum
3154 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0b00000000000000000000000000000001
3155 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0b00000000000000000000000000000010
3156 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0b00000000000000000000000000000100
3157 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0b00000000000000000000000000001000
3158 func toBits*(flags: openArray[VkPeerMemoryFeatureFlagBits]): VkPeerMemoryFeatureFlags =
3159 for flag in flags:
3160 result = VkPeerMemoryFeatureFlags(uint(result) or uint(flag))
3161 func toEnums*(number: VkPeerMemoryFeatureFlags): seq[VkPeerMemoryFeatureFlagBits] =
3162 for value in VkPeerMemoryFeatureFlagBits.items:
3163 if (value.ord and cint(number)) > 0:
3164 result.add value
3165 proc `==`*(a, b: VkPeerMemoryFeatureFlags): bool = cint(a) == cint(b)
3166 type
3167 VkMemoryAllocateFlagBits* {.size: sizeof(cint).} = enum
3168 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0b00000000000000000000000000000001
3169 VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0b00000000000000000000000000000010
3170 VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0b00000000000000000000000000000100
3171 func toBits*(flags: openArray[VkMemoryAllocateFlagBits]): VkMemoryAllocateFlags =
3172 for flag in flags:
3173 result = VkMemoryAllocateFlags(uint(result) or uint(flag))
3174 func toEnums*(number: VkMemoryAllocateFlags): seq[VkMemoryAllocateFlagBits] =
3175 for value in VkMemoryAllocateFlagBits.items:
3176 if (value.ord and cint(number)) > 0:
3177 result.add value
3178 proc `==`*(a, b: VkMemoryAllocateFlags): bool = cint(a) == cint(b)
3179 type
3180 VkDeviceGroupPresentModeFlagBitsKHR* {.size: sizeof(cint).} = enum
3181 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0b00000000000000000000000000000001
3182 VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0b00000000000000000000000000000010
3183 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0b00000000000000000000000000000100
3184 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0b00000000000000000000000000001000
3185 func toBits*(flags: openArray[VkDeviceGroupPresentModeFlagBitsKHR]): VkDeviceGroupPresentModeFlagsKHR =
3186 for flag in flags:
3187 result = VkDeviceGroupPresentModeFlagsKHR(uint(result) or uint(flag))
3188 func toEnums*(number: VkDeviceGroupPresentModeFlagsKHR): seq[VkDeviceGroupPresentModeFlagBitsKHR] =
3189 for value in VkDeviceGroupPresentModeFlagBitsKHR.items:
3190 if (value.ord and cint(number)) > 0:
3191 result.add value
3192 proc `==`*(a, b: VkDeviceGroupPresentModeFlagsKHR): bool = cint(a) == cint(b)
3193 type
3194 VkSwapchainCreateFlagBitsKHR* {.size: sizeof(cint).} = enum
3195 VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0b00000000000000000000000000000001
3196 VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0b00000000000000000000000000000010
3197 VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0b00000000000000000000000000000100
3198 VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0b00000000000000000000000000001000
3199 VK_SWAPCHAIN_CREATE_RESERVED_4_BIT_EXT = 0b00000000000000000000000000010000
3200 func toBits*(flags: openArray[VkSwapchainCreateFlagBitsKHR]): VkSwapchainCreateFlagsKHR =
3201 for flag in flags:
3202 result = VkSwapchainCreateFlagsKHR(uint(result) or uint(flag))
3203 func toEnums*(number: VkSwapchainCreateFlagsKHR): seq[VkSwapchainCreateFlagBitsKHR] =
3204 for value in VkSwapchainCreateFlagBitsKHR.items:
3205 if (value.ord and cint(number)) > 0:
3206 result.add value
3207 proc `==`*(a, b: VkSwapchainCreateFlagsKHR): bool = cint(a) == cint(b)
3208 type
3209 VkViewportCoordinateSwizzleNV* {.size: sizeof(cint).} = enum
3210 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0
3211 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1
3212 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2
3213 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3
3214 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4
3215 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5
3216 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6
3217 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7
3218 VkDiscardRectangleModeEXT* {.size: sizeof(cint).} = enum
3219 VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0
3220 VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1
3221 VkSubpassDescriptionFlagBits* {.size: sizeof(cint).} = enum
3222 VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0b00000000000000000000000000000001
3223 VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0b00000000000000000000000000000010
3224 VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0b00000000000000000000000000000100
3225 VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0b00000000000000000000000000001000
3226 VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0b00000000000000000000000000010000
3227 VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0b00000000000000000000000000100000
3228 VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0b00000000000000000000000001000000
3229 VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0b00000000000000000000000010000000
3230 func toBits*(flags: openArray[VkSubpassDescriptionFlagBits]): VkSubpassDescriptionFlags =
3231 for flag in flags:
3232 result = VkSubpassDescriptionFlags(uint(result) or uint(flag))
3233 func toEnums*(number: VkSubpassDescriptionFlags): seq[VkSubpassDescriptionFlagBits] =
3234 for value in VkSubpassDescriptionFlagBits.items:
3235 if (value.ord and cint(number)) > 0:
3236 result.add value
3237 proc `==`*(a, b: VkSubpassDescriptionFlags): bool = cint(a) == cint(b)
3238 type
3239 VkPointClippingBehavior* {.size: sizeof(cint).} = enum
3240 VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0
3241 VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1
3242 VkSamplerReductionMode* {.size: sizeof(cint).} = enum
3243 VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0
3244 VK_SAMPLER_REDUCTION_MODE_MIN = 1
3245 VK_SAMPLER_REDUCTION_MODE_MAX = 2
3246 VkTessellationDomainOrigin* {.size: sizeof(cint).} = enum
3247 VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0
3248 VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1
3249 VkSamplerYcbcrModelConversion* {.size: sizeof(cint).} = enum
3250 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0
3251 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1
3252 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2
3253 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3
3254 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4
3255 VkSamplerYcbcrRange* {.size: sizeof(cint).} = enum
3256 VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0
3257 VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1
3258 VkChromaLocation* {.size: sizeof(cint).} = enum
3259 VK_CHROMA_LOCATION_COSITED_EVEN = 0
3260 VK_CHROMA_LOCATION_MIDPOINT = 1
3261 VkBlendOverlapEXT* {.size: sizeof(cint).} = enum
3262 VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0
3263 VK_BLEND_OVERLAP_DISJOINT_EXT = 1
3264 VK_BLEND_OVERLAP_CONJOINT_EXT = 2
3265 VkCoverageModulationModeNV* {.size: sizeof(cint).} = enum
3266 VK_COVERAGE_MODULATION_MODE_NONE_NV = 0
3267 VK_COVERAGE_MODULATION_MODE_RGB_NV = 1
3268 VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2
3269 VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3
3270 VkCoverageReductionModeNV* {.size: sizeof(cint).} = enum
3271 VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0
3272 VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1
3273 VkValidationCacheHeaderVersionEXT* {.size: sizeof(cint).} = enum
3274 VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1
3275 VkShaderInfoTypeAMD* {.size: sizeof(cint).} = enum
3276 VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0
3277 VK_SHADER_INFO_TYPE_BINARY_AMD = 1
3278 VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2
3279 VkQueueGlobalPriorityKHR* {.size: sizeof(cint).} = enum
3280 VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = 128
3281 VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = 256
3282 VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = 512
3283 VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = 1024
3284 VkDebugUtilsMessageSeverityFlagBitsEXT* {.size: sizeof(cint).} = enum
3285 VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0b00000000000000000000000000000001
3286 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0b00000000000000000000000000010000
3287 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0b00000000000000000000000100000000
3288 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0b00000000000000000001000000000000
3289 func toBits*(flags: openArray[VkDebugUtilsMessageSeverityFlagBitsEXT]): VkDebugUtilsMessageSeverityFlagsEXT =
3290 for flag in flags:
3291 result = VkDebugUtilsMessageSeverityFlagsEXT(uint(result) or uint(flag))
3292 func toEnums*(number: VkDebugUtilsMessageSeverityFlagsEXT): seq[VkDebugUtilsMessageSeverityFlagBitsEXT] =
3293 for value in VkDebugUtilsMessageSeverityFlagBitsEXT.items:
3294 if (value.ord and cint(number)) > 0:
3295 result.add value
3296 proc `==`*(a, b: VkDebugUtilsMessageSeverityFlagsEXT): bool = cint(a) == cint(b)
3297 type
3298 VkDebugUtilsMessageTypeFlagBitsEXT* {.size: sizeof(cint).} = enum
3299 VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0b00000000000000000000000000000001
3300 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0b00000000000000000000000000000010
3301 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0b00000000000000000000000000000100
3302 VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0b00000000000000000000000000001000
3303 func toBits*(flags: openArray[VkDebugUtilsMessageTypeFlagBitsEXT]): VkDebugUtilsMessageTypeFlagsEXT =
3304 for flag in flags:
3305 result = VkDebugUtilsMessageTypeFlagsEXT(uint(result) or uint(flag))
3306 func toEnums*(number: VkDebugUtilsMessageTypeFlagsEXT): seq[VkDebugUtilsMessageTypeFlagBitsEXT] =
3307 for value in VkDebugUtilsMessageTypeFlagBitsEXT.items:
3308 if (value.ord and cint(number)) > 0:
3309 result.add value
3310 proc `==`*(a, b: VkDebugUtilsMessageTypeFlagsEXT): bool = cint(a) == cint(b)
3311 type
3312 VkConservativeRasterizationModeEXT* {.size: sizeof(cint).} = enum
3313 VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0
3314 VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1
3315 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2
3316 VkDescriptorBindingFlagBits* {.size: sizeof(cint).} = enum
3317 VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0b00000000000000000000000000000001
3318 VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0b00000000000000000000000000000010
3319 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0b00000000000000000000000000000100
3320 VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0b00000000000000000000000000001000
3321 VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM = 0b00000000000000000000000000010000
3322 func toBits*(flags: openArray[VkDescriptorBindingFlagBits]): VkDescriptorBindingFlags =
3323 for flag in flags:
3324 result = VkDescriptorBindingFlags(uint(result) or uint(flag))
3325 func toEnums*(number: VkDescriptorBindingFlags): seq[VkDescriptorBindingFlagBits] =
3326 for value in VkDescriptorBindingFlagBits.items:
3327 if (value.ord and cint(number)) > 0:
3328 result.add value
3329 proc `==`*(a, b: VkDescriptorBindingFlags): bool = cint(a) == cint(b)
3330 type
3331 VkVendorId* {.size: sizeof(cint).} = enum
3332 VK_VENDOR_ID_VIV = 65537
3333 VK_VENDOR_ID_VSI = 65538
3334 VK_VENDOR_ID_KAZAN = 65539
3335 VK_VENDOR_ID_CODEPLAY = 65540
3336 VK_VENDOR_ID_MESA = 65541
3337 VK_VENDOR_ID_POCL = 65542
3338 VkDriverId* {.size: sizeof(cint).} = enum
3339 VK_DRIVER_ID_AMD_PROPRIETARY = 1
3340 VK_DRIVER_ID_AMD_OPEN_SOURCE = 2
3341 VK_DRIVER_ID_MESA_RADV = 3
3342 VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4
3343 VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5
3344 VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6
3345 VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7
3346 VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8
3347 VK_DRIVER_ID_ARM_PROPRIETARY = 9
3348 VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10
3349 VK_DRIVER_ID_GGP_PROPRIETARY = 11
3350 VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12
3351 VK_DRIVER_ID_MESA_LLVMPIPE = 13
3352 VK_DRIVER_ID_MOLTENVK = 14
3353 VK_DRIVER_ID_COREAVI_PROPRIETARY = 15
3354 VK_DRIVER_ID_JUICE_PROPRIETARY = 16
3355 VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17
3356 VK_DRIVER_ID_MESA_TURNIP = 18
3357 VK_DRIVER_ID_MESA_V3DV = 19
3358 VK_DRIVER_ID_MESA_PANVK = 20
3359 VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21
3360 VK_DRIVER_ID_MESA_VENUS = 22
3361 VK_DRIVER_ID_MESA_DOZEN = 23
3362 VK_DRIVER_ID_MESA_NVK = 24
3363 VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25
3364 VkConditionalRenderingFlagBitsEXT* {.size: sizeof(cint).} = enum
3365 VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0b00000000000000000000000000000001
3366 func toBits*(flags: openArray[VkConditionalRenderingFlagBitsEXT]): VkConditionalRenderingFlagsEXT =
3367 for flag in flags:
3368 result = VkConditionalRenderingFlagsEXT(uint(result) or uint(flag))
3369 func toEnums*(number: VkConditionalRenderingFlagsEXT): seq[VkConditionalRenderingFlagBitsEXT] =
3370 for value in VkConditionalRenderingFlagBitsEXT.items:
3371 if (value.ord and cint(number)) > 0:
3372 result.add value
3373 proc `==`*(a, b: VkConditionalRenderingFlagsEXT): bool = cint(a) == cint(b)
3374 type
3375 VkResolveModeFlagBits* {.size: sizeof(cint).} = enum
3376 VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0b00000000000000000000000000000001
3377 VK_RESOLVE_MODE_AVERAGE_BIT = 0b00000000000000000000000000000010
3378 VK_RESOLVE_MODE_MIN_BIT = 0b00000000000000000000000000000100
3379 VK_RESOLVE_MODE_MAX_BIT = 0b00000000000000000000000000001000
3380 func toBits*(flags: openArray[VkResolveModeFlagBits]): VkResolveModeFlags =
3381 for flag in flags:
3382 result = VkResolveModeFlags(uint(result) or uint(flag))
3383 func toEnums*(number: VkResolveModeFlags): seq[VkResolveModeFlagBits] =
3384 for value in VkResolveModeFlagBits.items:
3385 if (value.ord and cint(number)) > 0:
3386 result.add value
3387 proc `==`*(a, b: VkResolveModeFlags): bool = cint(a) == cint(b)
3388 const
3389 VK_RESOLVE_MODE_NONE* = 0
3390 type
3391 VkShadingRatePaletteEntryNV* {.size: sizeof(cint).} = enum
3392 VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0
3393 VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1
3394 VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2
3395 VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3
3396 VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4
3397 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5
3398 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6
3399 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7
3400 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8
3401 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9
3402 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10
3403 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11
3404 VkCoarseSampleOrderTypeNV* {.size: sizeof(cint).} = enum
3405 VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0
3406 VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1
3407 VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2
3408 VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3
3409 VkGeometryInstanceFlagBitsKHR* {.size: sizeof(cint).} = enum
3410 VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0b00000000000000000000000000000001
3411 VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0b00000000000000000000000000000010
3412 VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0b00000000000000000000000000000100
3413 VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0b00000000000000000000000000001000
3414 VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0b00000000000000000000000000010000
3415 VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0b00000000000000000000000000100000
3416 func toBits*(flags: openArray[VkGeometryInstanceFlagBitsKHR]): VkGeometryInstanceFlagsKHR =
3417 for flag in flags:
3418 result = VkGeometryInstanceFlagsKHR(uint(result) or uint(flag))
3419 func toEnums*(number: VkGeometryInstanceFlagsKHR): seq[VkGeometryInstanceFlagBitsKHR] =
3420 for value in VkGeometryInstanceFlagBitsKHR.items:
3421 if (value.ord and cint(number)) > 0:
3422 result.add value
3423 proc `==`*(a, b: VkGeometryInstanceFlagsKHR): bool = cint(a) == cint(b)
3424 type
3425 VkGeometryFlagBitsKHR* {.size: sizeof(cint).} = enum
3426 VK_GEOMETRY_OPAQUE_BIT_KHR = 0b00000000000000000000000000000001
3427 VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0b00000000000000000000000000000010
3428 func toBits*(flags: openArray[VkGeometryFlagBitsKHR]): VkGeometryFlagsKHR =
3429 for flag in flags:
3430 result = VkGeometryFlagsKHR(uint(result) or uint(flag))
3431 func toEnums*(number: VkGeometryFlagsKHR): seq[VkGeometryFlagBitsKHR] =
3432 for value in VkGeometryFlagBitsKHR.items:
3433 if (value.ord and cint(number)) > 0:
3434 result.add value
3435 proc `==`*(a, b: VkGeometryFlagsKHR): bool = cint(a) == cint(b)
3436 type
3437 VkBuildAccelerationStructureFlagBitsKHR* {.size: sizeof(cint).} = enum
3438 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0b00000000000000000000000000000001
3439 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0b00000000000000000000000000000010
3440 VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0b00000000000000000000000000000100
3441 VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0b00000000000000000000000000001000
3442 VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0b00000000000000000000000000010000
3443 VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0b00000000000000000000000000100000
3444 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0b00000000000000000000000001000000
3445 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0b00000000000000000000000010000000
3446 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0b00000000000000000000000100000000
3447 VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_BIT_9_NV = 0b00000000000000000000001000000000
3448 VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_BIT_10_NV = 0b00000000000000000000010000000000
3449 func toBits*(flags: openArray[VkBuildAccelerationStructureFlagBitsKHR]): VkBuildAccelerationStructureFlagsKHR =
3450 for flag in flags:
3451 result = VkBuildAccelerationStructureFlagsKHR(uint(result) or uint(flag))
3452 func toEnums*(number: VkBuildAccelerationStructureFlagsKHR): seq[VkBuildAccelerationStructureFlagBitsKHR] =
3453 for value in VkBuildAccelerationStructureFlagBitsKHR.items:
3454 if (value.ord and cint(number)) > 0:
3455 result.add value
3456 proc `==`*(a, b: VkBuildAccelerationStructureFlagsKHR): bool = cint(a) == cint(b)
3457 type
3458 VkAccelerationStructureCreateFlagBitsKHR* {.size: sizeof(cint).} = enum
3459 VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0b00000000000000000000000000000001
3460 VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0b00000000000000000000000000000100
3461 VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000001000
3462 func toBits*(flags: openArray[VkAccelerationStructureCreateFlagBitsKHR]): VkAccelerationStructureCreateFlagsKHR =
3463 for flag in flags:
3464 result = VkAccelerationStructureCreateFlagsKHR(uint(result) or uint(flag))
3465 func toEnums*(number: VkAccelerationStructureCreateFlagsKHR): seq[VkAccelerationStructureCreateFlagBitsKHR] =
3466 for value in VkAccelerationStructureCreateFlagBitsKHR.items:
3467 if (value.ord and cint(number)) > 0:
3468 result.add value
3469 proc `==`*(a, b: VkAccelerationStructureCreateFlagsKHR): bool = cint(a) == cint(b)
3470 type
3471 VkCopyAccelerationStructureModeKHR* {.size: sizeof(cint).} = enum
3472 VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0
3473 VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1
3474 VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2
3475 VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3
3476 VkBuildAccelerationStructureModeKHR* {.size: sizeof(cint).} = enum
3477 VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0
3478 VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1
3479 VkAccelerationStructureTypeKHR* {.size: sizeof(cint).} = enum
3480 VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0
3481 VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1
3482 VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2
3483 VkGeometryTypeKHR* {.size: sizeof(cint).} = enum
3484 VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0
3485 VK_GEOMETRY_TYPE_AABBS_KHR = 1
3486 VK_GEOMETRY_TYPE_INSTANCES_KHR = 2
3487 VkAccelerationStructureMemoryRequirementsTypeNV* {.size: sizeof(cint).} = enum
3488 VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0
3489 VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1
3490 VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2
3491 VkAccelerationStructureBuildTypeKHR* {.size: sizeof(cint).} = enum
3492 VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0
3493 VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1
3494 VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2
3495 VkRayTracingShaderGroupTypeKHR* {.size: sizeof(cint).} = enum
3496 VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0
3497 VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1
3498 VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2
3499 VkAccelerationStructureCompatibilityKHR* {.size: sizeof(cint).} = enum
3500 VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0
3501 VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1
3502 VkShaderGroupShaderKHR* {.size: sizeof(cint).} = enum
3503 VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0
3504 VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1
3505 VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2
3506 VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3
3507 VkMemoryOverallocationBehaviorAMD* {.size: sizeof(cint).} = enum
3508 VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0
3509 VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1
3510 VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2
3511 VkFramebufferCreateFlagBits* {.size: sizeof(cint).} = enum
3512 VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0b00000000000000000000000000000001
3513 func toBits*(flags: openArray[VkFramebufferCreateFlagBits]): VkFramebufferCreateFlags =
3514 for flag in flags:
3515 result = VkFramebufferCreateFlags(uint(result) or uint(flag))
3516 func toEnums*(number: VkFramebufferCreateFlags): seq[VkFramebufferCreateFlagBits] =
3517 for value in VkFramebufferCreateFlagBits.items:
3518 if (value.ord and cint(number)) > 0:
3519 result.add value
3520 proc `==`*(a, b: VkFramebufferCreateFlags): bool = cint(a) == cint(b)
3521 type
3522 VkScopeNV* {.size: sizeof(cint).} = enum
3523 VK_SCOPE_DEVICE_NV = 1
3524 VK_SCOPE_WORKGROUP_NV = 2
3525 VK_SCOPE_SUBGROUP_NV = 3
3526 VK_SCOPE_QUEUE_FAMILY_NV = 5
3527 VkComponentTypeNV* {.size: sizeof(cint).} = enum
3528 VK_COMPONENT_TYPE_FLOAT16_NV = 0
3529 VK_COMPONENT_TYPE_FLOAT32_NV = 1
3530 VK_COMPONENT_TYPE_FLOAT64_NV = 2
3531 VK_COMPONENT_TYPE_SINT8_NV = 3
3532 VK_COMPONENT_TYPE_SINT16_NV = 4
3533 VK_COMPONENT_TYPE_SINT32_NV = 5
3534 VK_COMPONENT_TYPE_SINT64_NV = 6
3535 VK_COMPONENT_TYPE_UINT8_NV = 7
3536 VK_COMPONENT_TYPE_UINT16_NV = 8
3537 VK_COMPONENT_TYPE_UINT32_NV = 9
3538 VK_COMPONENT_TYPE_UINT64_NV = 10
3539 VkDeviceDiagnosticsConfigFlagBitsNV* {.size: sizeof(cint).} = enum
3540 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0b00000000000000000000000000000001
3541 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0b00000000000000000000000000000010
3542 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0b00000000000000000000000000000100
3543 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0b00000000000000000000000000001000
3544 func toBits*(flags: openArray[VkDeviceDiagnosticsConfigFlagBitsNV]): VkDeviceDiagnosticsConfigFlagsNV =
3545 for flag in flags:
3546 result = VkDeviceDiagnosticsConfigFlagsNV(uint(result) or uint(flag))
3547 func toEnums*(number: VkDeviceDiagnosticsConfigFlagsNV): seq[VkDeviceDiagnosticsConfigFlagBitsNV] =
3548 for value in VkDeviceDiagnosticsConfigFlagBitsNV.items:
3549 if (value.ord and cint(number)) > 0:
3550 result.add value
3551 proc `==`*(a, b: VkDeviceDiagnosticsConfigFlagsNV): bool = cint(a) == cint(b)
3552 type
3553 VkPipelineCreationFeedbackFlagBits* {.size: sizeof(cint).} = enum
3554 VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0b00000000000000000000000000000001
3555 VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0b00000000000000000000000000000010
3556 VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0b00000000000000000000000000000100
3557 func toBits*(flags: openArray[VkPipelineCreationFeedbackFlagBits]): VkPipelineCreationFeedbackFlags =
3558 for flag in flags:
3559 result = VkPipelineCreationFeedbackFlags(uint(result) or uint(flag))
3560 func toEnums*(number: VkPipelineCreationFeedbackFlags): seq[VkPipelineCreationFeedbackFlagBits] =
3561 for value in VkPipelineCreationFeedbackFlagBits.items:
3562 if (value.ord and cint(number)) > 0:
3563 result.add value
3564 proc `==`*(a, b: VkPipelineCreationFeedbackFlags): bool = cint(a) == cint(b)
3565 type
3566 VkFullScreenExclusiveEXT* {.size: sizeof(cint).} = enum
3567 VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0
3568 VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1
3569 VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2
3570 VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3
3571 VkPerformanceCounterScopeKHR* {.size: sizeof(cint).} = enum
3572 VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0
3573 VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1
3574 VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2
3575 VkMemoryDecompressionMethodFlagBitsNV* {.size: 8.} = enum
3576 VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0b0000000000000000000000000000000000000000000000000000000000000001
3577 func toBits*(flags: openArray[VkMemoryDecompressionMethodFlagBitsNV]): VkMemoryDecompressionMethodFlagsNV =
3578 for flag in flags:
3579 result = VkMemoryDecompressionMethodFlagsNV(uint64(result) or uint64(flag))
3580 func toEnums*(number: VkMemoryDecompressionMethodFlagsNV): seq[VkMemoryDecompressionMethodFlagBitsNV] =
3581 for value in VkMemoryDecompressionMethodFlagBitsNV.items:
3582 if (cast[uint64](value) and uint64(number)) > 0:
3583 result.add value
3584 proc `==`*(a, b: VkMemoryDecompressionMethodFlagsNV): bool = uint64(a) == uint64(b)
3585 type
3586 VkPerformanceCounterUnitKHR* {.size: sizeof(cint).} = enum
3587 VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0
3588 VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1
3589 VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2
3590 VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3
3591 VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4
3592 VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5
3593 VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6
3594 VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7
3595 VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8
3596 VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9
3597 VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10
3598 VkPerformanceCounterStorageKHR* {.size: sizeof(cint).} = enum
3599 VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0
3600 VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1
3601 VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2
3602 VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3
3603 VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4
3604 VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5
3605 VkPerformanceCounterDescriptionFlagBitsKHR* {.size: sizeof(cint).} = enum
3606 VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0b00000000000000000000000000000001
3607 VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0b00000000000000000000000000000010
3608 func toBits*(flags: openArray[VkPerformanceCounterDescriptionFlagBitsKHR]): VkPerformanceCounterDescriptionFlagsKHR =
3609 for flag in flags:
3610 result = VkPerformanceCounterDescriptionFlagsKHR(uint(result) or uint(flag))
3611 func toEnums*(number: VkPerformanceCounterDescriptionFlagsKHR): seq[VkPerformanceCounterDescriptionFlagBitsKHR] =
3612 for value in VkPerformanceCounterDescriptionFlagBitsKHR.items:
3613 if (value.ord and cint(number)) > 0:
3614 result.add value
3615 proc `==`*(a, b: VkPerformanceCounterDescriptionFlagsKHR): bool = cint(a) == cint(b)
3616 type
3617 VkPerformanceConfigurationTypeINTEL* {.size: sizeof(cint).} = enum
3618 VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0
3619 VkQueryPoolSamplingModeINTEL* {.size: sizeof(cint).} = enum
3620 VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0
3621 VkPerformanceOverrideTypeINTEL* {.size: sizeof(cint).} = enum
3622 VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0
3623 VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1
3624 VkPerformanceParameterTypeINTEL* {.size: sizeof(cint).} = enum
3625 VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0
3626 VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1
3627 VkPerformanceValueTypeINTEL* {.size: sizeof(cint).} = enum
3628 VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0
3629 VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1
3630 VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2
3631 VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3
3632 VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4
3633 VkShaderFloatControlsIndependence* {.size: sizeof(cint).} = enum
3634 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0
3635 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1
3636 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2
3637 VkPipelineExecutableStatisticFormatKHR* {.size: sizeof(cint).} = enum
3638 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0
3639 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1
3640 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2
3641 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3
3642 VkLineRasterizationModeEXT* {.size: sizeof(cint).} = enum
3643 VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0
3644 VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1
3645 VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2
3646 VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3
3647 VkFaultLevel* {.size: sizeof(cint).} = enum
3648 VK_FAULT_LEVEL_UNASSIGNED = 0
3649 VK_FAULT_LEVEL_CRITICAL = 1
3650 VK_FAULT_LEVEL_RECOVERABLE = 2
3651 VK_FAULT_LEVEL_WARNING = 3
3652 VkFaultType* {.size: sizeof(cint).} = enum
3653 VK_FAULT_TYPE_INVALID = 0
3654 VK_FAULT_TYPE_UNASSIGNED = 1
3655 VK_FAULT_TYPE_IMPLEMENTATION = 2
3656 VK_FAULT_TYPE_SYSTEM = 3
3657 VK_FAULT_TYPE_PHYSICAL_DEVICE = 4
3658 VK_FAULT_TYPE_COMMAND_BUFFER_FULL = 5
3659 VK_FAULT_TYPE_INVALID_API_USAGE = 6
3660 VkFaultQueryBehavior* {.size: sizeof(cint).} = enum
3661 VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS = 0
3662 VkToolPurposeFlagBits* {.size: sizeof(cint).} = enum
3663 VK_TOOL_PURPOSE_VALIDATION_BIT = 0b00000000000000000000000000000001
3664 VK_TOOL_PURPOSE_PROFILING_BIT = 0b00000000000000000000000000000010
3665 VK_TOOL_PURPOSE_TRACING_BIT = 0b00000000000000000000000000000100
3666 VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0b00000000000000000000000000001000
3667 VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0b00000000000000000000000000010000
3668 VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0b00000000000000000000000000100000
3669 VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0b00000000000000000000000001000000
3670 func toBits*(flags: openArray[VkToolPurposeFlagBits]): VkToolPurposeFlags =
3671 for flag in flags:
3672 result = VkToolPurposeFlags(uint(result) or uint(flag))
3673 func toEnums*(number: VkToolPurposeFlags): seq[VkToolPurposeFlagBits] =
3674 for value in VkToolPurposeFlagBits.items:
3675 if (value.ord and cint(number)) > 0:
3676 result.add value
3677 proc `==`*(a, b: VkToolPurposeFlags): bool = cint(a) == cint(b)
3678 type
3679 VkPipelineMatchControl* {.size: sizeof(cint).} = enum
3680 VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH = 0
3681 VkFragmentShadingRateCombinerOpKHR* {.size: sizeof(cint).} = enum
3682 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0
3683 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1
3684 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2
3685 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3
3686 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4
3687 VkFragmentShadingRateNV* {.size: sizeof(cint).} = enum
3688 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0
3689 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1
3690 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4
3691 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5
3692 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6
3693 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9
3694 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10
3695 VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11
3696 VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12
3697 VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13
3698 VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14
3699 VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15
3700 VkFragmentShadingRateTypeNV* {.size: sizeof(cint).} = enum
3701 VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0
3702 VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1
3703 VkSubpassMergeStatusEXT* {.size: sizeof(cint).} = enum
3704 VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0
3705 VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1
3706 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2
3707 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3
3708 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4
3709 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5
3710 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6
3711 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7
3712 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8
3713 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9
3714 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10
3715 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11
3716 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12
3717 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13
3718 VkAccessFlagBits2* {.size: 8.} = enum
3719 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000000001
3720 VK_ACCESS_2_INDEX_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000000010
3721 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000000100
3722 VK_ACCESS_2_UNIFORM_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000001000
3723 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000010000
3724 VK_ACCESS_2_SHADER_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000100000
3725 VK_ACCESS_2_SHADER_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000000000001000000
3726 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000010000000
3727 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000000000100000000
3728 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0b0000000000000000000000000000000000000000000000000000001000000000
3729 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000000010000000000
3730 VK_ACCESS_2_TRANSFER_READ_BIT = 0b0000000000000000000000000000000000000000000000000000100000000000
3731 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000001000000000000
3732 VK_ACCESS_2_HOST_READ_BIT = 0b0000000000000000000000000000000000000000000000000010000000000000
3733 VK_ACCESS_2_HOST_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000100000000000000
3734 VK_ACCESS_2_MEMORY_READ_BIT = 0b0000000000000000000000000000000000000000000000001000000000000000
3735 VK_ACCESS_2_MEMORY_WRITE_BIT = 0b0000000000000000000000000000000000000000000000010000000000000000
3736 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0b0000000000000000000000000000000000000000000000100000000000000000
3737 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0b0000000000000000000000000000000000000000000001000000000000000000
3738 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0b0000000000000000000000000000000000000000000010000000000000000000
3739 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0b0000000000000000000000000000000000000000000100000000000000000000
3740 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0b0000000000000000000000000000000000000000001000000000000000000000
3741 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0b0000000000000000000000000000000000000000010000000000000000000000
3742 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0b0000000000000000000000000000000000000000100000000000000000000000
3743 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0b0000000000000000000000000000000000000001000000000000000000000000
3744 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0b0000000000000000000000000000000000000010000000000000000000000000
3745 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0b0000000000000000000000000000000000000100000000000000000000000000
3746 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0b0000000000000000000000000000000000001000000000000000000000000000
3747 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0b0000000000000000000000000000000100000000000000000000000000000000
3748 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0b0000000000000000000000000000001000000000000000000000000000000000
3749 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0b0000000000000000000000000000010000000000000000000000000000000000
3750 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0b0000000000000000000000000000100000000000000000000000000000000000
3751 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0b0000000000000000000000000001000000000000000000000000000000000000
3752 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0b0000000000000000000000000010000000000000000000000000000000000000
3753 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0b0000000000000000000000000100000000000000000000000000000000000000
3754 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0b0000000000000000000000001000000000000000000000000000000000000000
3755 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0b0000000000000000000000010000000000000000000000000000000000000000
3756 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0b0000000000000000000000100000000000000000000000000000000000000000
3757 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0b0000000000000000000001000000000000000000000000000000000000000000
3758 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0b0000000000000000000010000000000000000000000000000000000000000000
3759 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0b0000000000000000000100000000000000000000000000000000000000000000
3760 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0b0000000000000000001000000000000000000000000000000000000000000000
3761 VK_ACCESS_2_RESERVED_46_BIT_EXT = 0b0000000000000000010000000000000000000000000000000000000000000000
3762 func toBits*(flags: openArray[VkAccessFlagBits2]): VkAccessFlags2 =
3763 for flag in flags:
3764 result = VkAccessFlags2(uint64(result) or uint64(flag))
3765 func toEnums*(number: VkAccessFlags2): seq[VkAccessFlagBits2] =
3766 for value in VkAccessFlagBits2.items:
3767 if (cast[uint64](value) and uint64(number)) > 0:
3768 result.add value
3769 proc `==`*(a, b: VkAccessFlags2): bool = uint64(a) == uint64(b)
3770 const
3771 VK_ACCESS_2_NONE* = 0
3772 type
3773 VkPipelineStageFlagBits2* {.size: 8.} = enum
3774 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0b0000000000000000000000000000000000000000000000000000000000000001
3775 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0b0000000000000000000000000000000000000000000000000000000000000010
3776 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0b0000000000000000000000000000000000000000000000000000000000000100
3777 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000000001000
3778 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000000010000
3779 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000000100000
3780 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000001000000
3781 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000010000000
3782 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0b0000000000000000000000000000000000000000000000000000000100000000
3783 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0b0000000000000000000000000000000000000000000000000000001000000000
3784 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0b0000000000000000000000000000000000000000000000000000010000000000
3785 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000100000000000
3786 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0b0000000000000000000000000000000000000000000000000001000000000000
3787 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0b0000000000000000000000000000000000000000000000000010000000000000
3788 VK_PIPELINE_STAGE_2_HOST_BIT = 0b0000000000000000000000000000000000000000000000000100000000000000
3789 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0b0000000000000000000000000000000000000000000000001000000000000000
3790 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0b0000000000000000000000000000000000000000000000010000000000000000
3791 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0b0000000000000000000000000000000000000000000000100000000000000000
3792 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0b0000000000000000000000000000000000000000000001000000000000000000
3793 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0b0000000000000000000000000000000000000000000010000000000000000000
3794 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0b0000000000000000000000000000000000000000000100000000000000000000
3795 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0b0000000000000000000000000000000000000000001000000000000000000000
3796 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b0000000000000000000000000000000000000000010000000000000000000000
3797 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0b0000000000000000000000000000000000000000100000000000000000000000
3798 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0b0000000000000000000000000000000000000001000000000000000000000000
3799 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0b0000000000000000000000000000000000000010000000000000000000000000
3800 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0b0000000000000000000000000000000000000100000000000000000000000000
3801 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0b0000000000000000000000000000000000001000000000000000000000000000
3802 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0b0000000000000000000000000000000000010000000000000000000000000000
3803 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0b0000000000000000000000000000000000100000000000000000000000000000
3804 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0b0000000000000000000000000000000001000000000000000000000000000000
3805 VK_PIPELINE_STAGE_2_COPY_BIT = 0b0000000000000000000000000000000100000000000000000000000000000000
3806 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0b0000000000000000000000000000001000000000000000000000000000000000
3807 VK_PIPELINE_STAGE_2_BLIT_BIT = 0b0000000000000000000000000000010000000000000000000000000000000000
3808 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0b0000000000000000000000000000100000000000000000000000000000000000
3809 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0b0000000000000000000000000001000000000000000000000000000000000000
3810 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0b0000000000000000000000000010000000000000000000000000000000000000
3811 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0b0000000000000000000000000100000000000000000000000000000000000000
3812 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0b0000000000000000000000001000000000000000000000000000000000000000
3813 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0b0000000000000000000000010000000000000000000000000000000000000000
3814 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0b0000000000000000000000100000000000000000000000000000000000000000
3815 func toBits*(flags: openArray[VkPipelineStageFlagBits2]): VkPipelineStageFlags2 =
3816 for flag in flags:
3817 result = VkPipelineStageFlags2(uint64(result) or uint64(flag))
3818 func toEnums*(number: VkPipelineStageFlags2): seq[VkPipelineStageFlagBits2] =
3819 for value in VkPipelineStageFlagBits2.items:
3820 if (cast[uint64](value) and uint64(number)) > 0:
3821 result.add value
3822 proc `==`*(a, b: VkPipelineStageFlags2): bool = uint64(a) == uint64(b)
3823 const
3824 VK_PIPELINE_STAGE_2_NONE* = 0
3825 type
3826 VkSubmitFlagBits* {.size: sizeof(cint).} = enum
3827 VK_SUBMIT_PROTECTED_BIT = 0b00000000000000000000000000000001
3828 func toBits*(flags: openArray[VkSubmitFlagBits]): VkSubmitFlags =
3829 for flag in flags:
3830 result = VkSubmitFlags(uint(result) or uint(flag))
3831 func toEnums*(number: VkSubmitFlags): seq[VkSubmitFlagBits] =
3832 for value in VkSubmitFlagBits.items:
3833 if (value.ord and cint(number)) > 0:
3834 result.add value
3835 proc `==`*(a, b: VkSubmitFlags): bool = cint(a) == cint(b)
3836 type
3837 VkEventCreateFlagBits* {.size: sizeof(cint).} = enum
3838 VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0b00000000000000000000000000000001
3839 func toBits*(flags: openArray[VkEventCreateFlagBits]): VkEventCreateFlags =
3840 for flag in flags:
3841 result = VkEventCreateFlags(uint(result) or uint(flag))
3842 func toEnums*(number: VkEventCreateFlags): seq[VkEventCreateFlagBits] =
3843 for value in VkEventCreateFlagBits.items:
3844 if (value.ord and cint(number)) > 0:
3845 result.add value
3846 proc `==`*(a, b: VkEventCreateFlags): bool = cint(a) == cint(b)
3847 type
3848 VkPipelineLayoutCreateFlagBits* {.size: sizeof(cint).} = enum
3849 VK_PIPELINE_LAYOUT_CREATE_RESERVED_0_BIT_AMD = 0b00000000000000000000000000000001
3850 VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0b00000000000000000000000000000010
3851 func toBits*(flags: openArray[VkPipelineLayoutCreateFlagBits]): VkPipelineLayoutCreateFlags =
3852 for flag in flags:
3853 result = VkPipelineLayoutCreateFlags(uint(result) or uint(flag))
3854 func toEnums*(number: VkPipelineLayoutCreateFlags): seq[VkPipelineLayoutCreateFlagBits] =
3855 for value in VkPipelineLayoutCreateFlagBits.items:
3856 if (value.ord and cint(number)) > 0:
3857 result.add value
3858 proc `==`*(a, b: VkPipelineLayoutCreateFlags): bool = cint(a) == cint(b)
3859 type
3860 VkSciSyncClientTypeNV* {.size: sizeof(cint).} = enum
3861 VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_NV = 0
3862 VK_SCI_SYNC_CLIENT_TYPE_WAITER_NV = 1
3863 VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_WAITER_NV = 2
3864 VkSciSyncPrimitiveTypeNV* {.size: sizeof(cint).} = enum
3865 VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV = 0
3866 VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV = 1
3867 VkProvokingVertexModeEXT* {.size: sizeof(cint).} = enum
3868 VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0
3869 VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1
3870 VkPipelineCacheValidationVersion* {.size: sizeof(cint).} = enum
3871 VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE = 1
3872 VkAccelerationStructureMotionInstanceTypeNV* {.size: sizeof(cint).} = enum
3873 VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0
3874 VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1
3875 VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2
3876 VkPipelineColorBlendStateCreateFlagBits* {.size: sizeof(cint).} = enum
3877 VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0b00000000000000000000000000000001
3878 func toBits*(flags: openArray[VkPipelineColorBlendStateCreateFlagBits]): VkPipelineColorBlendStateCreateFlags =
3879 for flag in flags:
3880 result = VkPipelineColorBlendStateCreateFlags(uint(result) or uint(flag))
3881 func toEnums*(number: VkPipelineColorBlendStateCreateFlags): seq[VkPipelineColorBlendStateCreateFlagBits] =
3882 for value in VkPipelineColorBlendStateCreateFlagBits.items:
3883 if (value.ord and cint(number)) > 0:
3884 result.add value
3885 proc `==`*(a, b: VkPipelineColorBlendStateCreateFlags): bool = cint(a) == cint(b)
3886 type
3887 VkPipelineDepthStencilStateCreateFlagBits* {.size: sizeof(cint).} = enum
3888 VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0b00000000000000000000000000000001
3889 VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0b00000000000000000000000000000010
3890 func toBits*(flags: openArray[VkPipelineDepthStencilStateCreateFlagBits]): VkPipelineDepthStencilStateCreateFlags =
3891 for flag in flags:
3892 result = VkPipelineDepthStencilStateCreateFlags(uint(result) or uint(flag))
3893 func toEnums*(number: VkPipelineDepthStencilStateCreateFlags): seq[VkPipelineDepthStencilStateCreateFlagBits] =
3894 for value in VkPipelineDepthStencilStateCreateFlagBits.items:
3895 if (value.ord and cint(number)) > 0:
3896 result.add value
3897 proc `==`*(a, b: VkPipelineDepthStencilStateCreateFlags): bool = cint(a) == cint(b)
3898 type
3899 VkGraphicsPipelineLibraryFlagBitsEXT* {.size: sizeof(cint).} = enum
3900 VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0b00000000000000000000000000000001
3901 VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0b00000000000000000000000000000010
3902 VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0b00000000000000000000000000000100
3903 VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0b00000000000000000000000000001000
3904 func toBits*(flags: openArray[VkGraphicsPipelineLibraryFlagBitsEXT]): VkGraphicsPipelineLibraryFlagsEXT =
3905 for flag in flags:
3906 result = VkGraphicsPipelineLibraryFlagsEXT(uint(result) or uint(flag))
3907 func toEnums*(number: VkGraphicsPipelineLibraryFlagsEXT): seq[VkGraphicsPipelineLibraryFlagBitsEXT] =
3908 for value in VkGraphicsPipelineLibraryFlagBitsEXT.items:
3909 if (value.ord and cint(number)) > 0:
3910 result.add value
3911 proc `==`*(a, b: VkGraphicsPipelineLibraryFlagsEXT): bool = cint(a) == cint(b)
3912 type
3913 VkDeviceAddressBindingFlagBitsEXT* {.size: sizeof(cint).} = enum
3914 VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0b00000000000000000000000000000001
3915 func toBits*(flags: openArray[VkDeviceAddressBindingFlagBitsEXT]): VkDeviceAddressBindingFlagsEXT =
3916 for flag in flags:
3917 result = VkDeviceAddressBindingFlagsEXT(uint(result) or uint(flag))
3918 func toEnums*(number: VkDeviceAddressBindingFlagsEXT): seq[VkDeviceAddressBindingFlagBitsEXT] =
3919 for value in VkDeviceAddressBindingFlagBitsEXT.items:
3920 if (value.ord and cint(number)) > 0:
3921 result.add value
3922 proc `==`*(a, b: VkDeviceAddressBindingFlagsEXT): bool = cint(a) == cint(b)
3923 type
3924 VkDeviceAddressBindingTypeEXT* {.size: sizeof(cint).} = enum
3925 VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0
3926 VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1
3927 VkPresentScalingFlagBitsEXT* {.size: sizeof(cint).} = enum
3928 VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0b00000000000000000000000000000001
3929 VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0b00000000000000000000000000000010
3930 VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0b00000000000000000000000000000100
3931 func toBits*(flags: openArray[VkPresentScalingFlagBitsEXT]): VkPresentScalingFlagsEXT =
3932 for flag in flags:
3933 result = VkPresentScalingFlagsEXT(uint(result) or uint(flag))
3934 func toEnums*(number: VkPresentScalingFlagsEXT): seq[VkPresentScalingFlagBitsEXT] =
3935 for value in VkPresentScalingFlagBitsEXT.items:
3936 if (value.ord and cint(number)) > 0:
3937 result.add value
3938 proc `==`*(a, b: VkPresentScalingFlagsEXT): bool = cint(a) == cint(b)
3939 type
3940 VkPresentGravityFlagBitsEXT* {.size: sizeof(cint).} = enum
3941 VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0b00000000000000000000000000000001
3942 VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0b00000000000000000000000000000010
3943 VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0b00000000000000000000000000000100
3944 func toBits*(flags: openArray[VkPresentGravityFlagBitsEXT]): VkPresentGravityFlagsEXT =
3945 for flag in flags:
3946 result = VkPresentGravityFlagsEXT(uint(result) or uint(flag))
3947 func toEnums*(number: VkPresentGravityFlagsEXT): seq[VkPresentGravityFlagBitsEXT] =
3948 for value in VkPresentGravityFlagBitsEXT.items:
3949 if (value.ord and cint(number)) > 0:
3950 result.add value
3951 proc `==`*(a, b: VkPresentGravityFlagsEXT): bool = cint(a) == cint(b)
3952 type
3953 VkVideoCodecOperationFlagBitsKHR* {.size: sizeof(cint).} = enum
3954 VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0b00000000000000000000000000000001
3955 VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0b00000000000000000000000000000010
3956 VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0b00000000000000010000000000000000
3957 VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0b00000000000000100000000000000000
3958 func toBits*(flags: openArray[VkVideoCodecOperationFlagBitsKHR]): VkVideoCodecOperationFlagsKHR =
3959 for flag in flags:
3960 result = VkVideoCodecOperationFlagsKHR(uint(result) or uint(flag))
3961 func toEnums*(number: VkVideoCodecOperationFlagsKHR): seq[VkVideoCodecOperationFlagBitsKHR] =
3962 for value in VkVideoCodecOperationFlagBitsKHR.items:
3963 if (value.ord and cint(number)) > 0:
3964 result.add value
3965 proc `==`*(a, b: VkVideoCodecOperationFlagsKHR): bool = cint(a) == cint(b)
3966 const
3967 VK_VIDEO_CODEC_OPERATION_NONE_KHR* = 0
3968 type
3969 VkVideoChromaSubsamplingFlagBitsKHR* {.size: sizeof(cint).} = enum
3970 VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0b00000000000000000000000000000001
3971 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0b00000000000000000000000000000010
3972 VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0b00000000000000000000000000000100
3973 VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0b00000000000000000000000000001000
3974 func toBits*(flags: openArray[VkVideoChromaSubsamplingFlagBitsKHR]): VkVideoChromaSubsamplingFlagsKHR =
3975 for flag in flags:
3976 result = VkVideoChromaSubsamplingFlagsKHR(uint(result) or uint(flag))
3977 func toEnums*(number: VkVideoChromaSubsamplingFlagsKHR): seq[VkVideoChromaSubsamplingFlagBitsKHR] =
3978 for value in VkVideoChromaSubsamplingFlagBitsKHR.items:
3979 if (value.ord and cint(number)) > 0:
3980 result.add value
3981 proc `==`*(a, b: VkVideoChromaSubsamplingFlagsKHR): bool = cint(a) == cint(b)
3982 const
3983 VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR* = 0
3984 type
3985 VkVideoComponentBitDepthFlagBitsKHR* {.size: sizeof(cint).} = enum
3986 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0b00000000000000000000000000000001
3987 VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0b00000000000000000000000000000100
3988 VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0b00000000000000000000000000010000
3989 func toBits*(flags: openArray[VkVideoComponentBitDepthFlagBitsKHR]): VkVideoComponentBitDepthFlagsKHR =
3990 for flag in flags:
3991 result = VkVideoComponentBitDepthFlagsKHR(uint(result) or uint(flag))
3992 func toEnums*(number: VkVideoComponentBitDepthFlagsKHR): seq[VkVideoComponentBitDepthFlagBitsKHR] =
3993 for value in VkVideoComponentBitDepthFlagBitsKHR.items:
3994 if (value.ord and cint(number)) > 0:
3995 result.add value
3996 proc `==`*(a, b: VkVideoComponentBitDepthFlagsKHR): bool = cint(a) == cint(b)
3997 const
3998 VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR* = 0
3999 type
4000 VkVideoCapabilityFlagBitsKHR* {.size: sizeof(cint).} = enum
4001 VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0b00000000000000000000000000000001
4002 VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0b00000000000000000000000000000010
4003 func toBits*(flags: openArray[VkVideoCapabilityFlagBitsKHR]): VkVideoCapabilityFlagsKHR =
4004 for flag in flags:
4005 result = VkVideoCapabilityFlagsKHR(uint(result) or uint(flag))
4006 func toEnums*(number: VkVideoCapabilityFlagsKHR): seq[VkVideoCapabilityFlagBitsKHR] =
4007 for value in VkVideoCapabilityFlagBitsKHR.items:
4008 if (value.ord and cint(number)) > 0:
4009 result.add value
4010 proc `==`*(a, b: VkVideoCapabilityFlagsKHR): bool = cint(a) == cint(b)
4011 type
4012 VkVideoSessionCreateFlagBitsKHR* {.size: sizeof(cint).} = enum
4013 VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0b00000000000000000000000000000001
4014 func toBits*(flags: openArray[VkVideoSessionCreateFlagBitsKHR]): VkVideoSessionCreateFlagsKHR =
4015 for flag in flags:
4016 result = VkVideoSessionCreateFlagsKHR(uint(result) or uint(flag))
4017 func toEnums*(number: VkVideoSessionCreateFlagsKHR): seq[VkVideoSessionCreateFlagBitsKHR] =
4018 for value in VkVideoSessionCreateFlagBitsKHR.items:
4019 if (value.ord and cint(number)) > 0:
4020 result.add value
4021 proc `==`*(a, b: VkVideoSessionCreateFlagsKHR): bool = cint(a) == cint(b)
4022 type
4023 VkVideoDecodeH264PictureLayoutFlagBitsKHR* {.size: sizeof(cint).} = enum
4024 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0b00000000000000000000000000000001
4025 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0b00000000000000000000000000000010
4026 func toBits*(flags: openArray[VkVideoDecodeH264PictureLayoutFlagBitsKHR]): VkVideoDecodeH264PictureLayoutFlagsKHR =
4027 for flag in flags:
4028 result = VkVideoDecodeH264PictureLayoutFlagsKHR(uint(result) or uint(flag))
4029 func toEnums*(number: VkVideoDecodeH264PictureLayoutFlagsKHR): seq[VkVideoDecodeH264PictureLayoutFlagBitsKHR] =
4030 for value in VkVideoDecodeH264PictureLayoutFlagBitsKHR.items:
4031 if (value.ord and cint(number)) > 0:
4032 result.add value
4033 proc `==`*(a, b: VkVideoDecodeH264PictureLayoutFlagsKHR): bool = cint(a) == cint(b)
4034 const
4035 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR* = 0
4036 type
4037 VkVideoCodingControlFlagBitsKHR* {.size: sizeof(cint).} = enum
4038 VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0b00000000000000000000000000000001
4039 VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0b00000000000000000000000000000010
4040 VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR = 0b00000000000000000000000000000100
4041 func toBits*(flags: openArray[VkVideoCodingControlFlagBitsKHR]): VkVideoCodingControlFlagsKHR =
4042 for flag in flags:
4043 result = VkVideoCodingControlFlagsKHR(uint(result) or uint(flag))
4044 func toEnums*(number: VkVideoCodingControlFlagsKHR): seq[VkVideoCodingControlFlagBitsKHR] =
4045 for value in VkVideoCodingControlFlagBitsKHR.items:
4046 if (value.ord and cint(number)) > 0:
4047 result.add value
4048 proc `==`*(a, b: VkVideoCodingControlFlagsKHR): bool = cint(a) == cint(b)
4049 type
4050 VkQueryResultStatusKHR* {.size: sizeof(cint).} = enum
4051 VK_QUERY_RESULT_STATUS_ERROR_KHR = -1
4052 VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0
4053 VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1
4054 VkVideoDecodeUsageFlagBitsKHR* {.size: sizeof(cint).} = enum
4055 VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0b00000000000000000000000000000001
4056 VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0b00000000000000000000000000000010
4057 VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0b00000000000000000000000000000100
4058 func toBits*(flags: openArray[VkVideoDecodeUsageFlagBitsKHR]): VkVideoDecodeUsageFlagsKHR =
4059 for flag in flags:
4060 result = VkVideoDecodeUsageFlagsKHR(uint(result) or uint(flag))
4061 func toEnums*(number: VkVideoDecodeUsageFlagsKHR): seq[VkVideoDecodeUsageFlagBitsKHR] =
4062 for value in VkVideoDecodeUsageFlagBitsKHR.items:
4063 if (value.ord and cint(number)) > 0:
4064 result.add value
4065 proc `==`*(a, b: VkVideoDecodeUsageFlagsKHR): bool = cint(a) == cint(b)
4066 const
4067 VK_VIDEO_DECODE_USAGE_DEFAULT_KHR* = 0
4068 type
4069 VkVideoDecodeCapabilityFlagBitsKHR* {.size: sizeof(cint).} = enum
4070 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0b00000000000000000000000000000001
4071 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0b00000000000000000000000000000010
4072 func toBits*(flags: openArray[VkVideoDecodeCapabilityFlagBitsKHR]): VkVideoDecodeCapabilityFlagsKHR =
4073 for flag in flags:
4074 result = VkVideoDecodeCapabilityFlagsKHR(uint(result) or uint(flag))
4075 func toEnums*(number: VkVideoDecodeCapabilityFlagsKHR): seq[VkVideoDecodeCapabilityFlagBitsKHR] =
4076 for value in VkVideoDecodeCapabilityFlagBitsKHR.items:
4077 if (value.ord and cint(number)) > 0:
4078 result.add value
4079 proc `==`*(a, b: VkVideoDecodeCapabilityFlagsKHR): bool = cint(a) == cint(b)
4080 type
4081 VkVideoEncodeUsageFlagBitsKHR* {.size: sizeof(cint).} = enum
4082 VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0b00000000000000000000000000000001
4083 VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0b00000000000000000000000000000010
4084 VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0b00000000000000000000000000000100
4085 VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0b00000000000000000000000000001000
4086 func toBits*(flags: openArray[VkVideoEncodeUsageFlagBitsKHR]): VkVideoEncodeUsageFlagsKHR =
4087 for flag in flags:
4088 result = VkVideoEncodeUsageFlagsKHR(uint(result) or uint(flag))
4089 func toEnums*(number: VkVideoEncodeUsageFlagsKHR): seq[VkVideoEncodeUsageFlagBitsKHR] =
4090 for value in VkVideoEncodeUsageFlagBitsKHR.items:
4091 if (value.ord and cint(number)) > 0:
4092 result.add value
4093 proc `==`*(a, b: VkVideoEncodeUsageFlagsKHR): bool = cint(a) == cint(b)
4094 const
4095 VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR* = 0
4096 type
4097 VkVideoEncodeContentFlagBitsKHR* {.size: sizeof(cint).} = enum
4098 VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0b00000000000000000000000000000001
4099 VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0b00000000000000000000000000000010
4100 VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0b00000000000000000000000000000100
4101 func toBits*(flags: openArray[VkVideoEncodeContentFlagBitsKHR]): VkVideoEncodeContentFlagsKHR =
4102 for flag in flags:
4103 result = VkVideoEncodeContentFlagsKHR(uint(result) or uint(flag))
4104 func toEnums*(number: VkVideoEncodeContentFlagsKHR): seq[VkVideoEncodeContentFlagBitsKHR] =
4105 for value in VkVideoEncodeContentFlagBitsKHR.items:
4106 if (value.ord and cint(number)) > 0:
4107 result.add value
4108 proc `==`*(a, b: VkVideoEncodeContentFlagsKHR): bool = cint(a) == cint(b)
4109 const
4110 VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR* = 0
4111 type
4112 VkVideoEncodeTuningModeKHR* {.size: sizeof(cint).} = enum
4113 VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0
4114 VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1
4115 VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2
4116 VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3
4117 VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4
4118 VkVideoEncodeCapabilityFlagBitsKHR* {.size: sizeof(cint).} = enum
4119 VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0b00000000000000000000000000000001
4120 func toBits*(flags: openArray[VkVideoEncodeCapabilityFlagBitsKHR]): VkVideoEncodeCapabilityFlagsKHR =
4121 for flag in flags:
4122 result = VkVideoEncodeCapabilityFlagsKHR(uint(result) or uint(flag))
4123 func toEnums*(number: VkVideoEncodeCapabilityFlagsKHR): seq[VkVideoEncodeCapabilityFlagBitsKHR] =
4124 for value in VkVideoEncodeCapabilityFlagBitsKHR.items:
4125 if (value.ord and cint(number)) > 0:
4126 result.add value
4127 proc `==`*(a, b: VkVideoEncodeCapabilityFlagsKHR): bool = cint(a) == cint(b)
4128 type
4129 VkVideoEncodeRateControlModeFlagBitsKHR* {.size: sizeof(cint).} = enum
4130 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0b00000000000000000000000000000001
4131 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0b00000000000000000000000000000010
4132 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0b00000000000000000000000000000100
4133 func toBits*(flags: openArray[VkVideoEncodeRateControlModeFlagBitsKHR]): VkVideoEncodeRateControlModeFlagsKHR =
4134 for flag in flags:
4135 result = VkVideoEncodeRateControlModeFlagsKHR(uint(result) or uint(flag))
4136 func toEnums*(number: VkVideoEncodeRateControlModeFlagsKHR): seq[VkVideoEncodeRateControlModeFlagBitsKHR] =
4137 for value in VkVideoEncodeRateControlModeFlagBitsKHR.items:
4138 if (value.ord and cint(number)) > 0:
4139 result.add value
4140 proc `==`*(a, b: VkVideoEncodeRateControlModeFlagsKHR): bool = cint(a) == cint(b)
4141 type
4142 VkVideoEncodeH264CapabilityFlagBitsEXT* {.size: sizeof(cint).} = enum
4143 VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0b00000000000000000000000000000001
4144 VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0b00000000000000000000000000000010
4145 VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0b00000000000000000000000000000100
4146 VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0b00000000000000000000000000001000
4147 VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0b00000000000000000000000000010000
4148 VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0b00000000000000000000000000100000
4149 VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0b00000000000000000000000001000000
4150 VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0b00000000000000000000000010000000
4151 VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0b00000000000000000000000100000000
4152 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0b00000000000000000000001000000000
4153 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0b00000000000000000000010000000000
4154 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0b00000000000000000000100000000000
4155 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0b00000000000000000001000000000000
4156 VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0b00000000000000000010000000000000
4157 VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0b00000000000000000100000000000000
4158 VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0b00000000000000001000000000000000
4159 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0b00000000000000010000000000000000
4160 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0b00000000000000100000000000000000
4161 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0b00000000000001000000000000000000
4162 VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0b00000000000010000000000000000000
4163 VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0b00000000000100000000000000000000
4164 VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0b00000000001000000000000000000000
4165 VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0b00000000010000000000000000000000
4166 VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0b00000000100000000000000000000000
4167 VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0b00000001000000000000000000000000
4168 func toBits*(flags: openArray[VkVideoEncodeH264CapabilityFlagBitsEXT]): VkVideoEncodeH264CapabilityFlagsEXT =
4169 for flag in flags:
4170 result = VkVideoEncodeH264CapabilityFlagsEXT(uint(result) or uint(flag))
4171 func toEnums*(number: VkVideoEncodeH264CapabilityFlagsEXT): seq[VkVideoEncodeH264CapabilityFlagBitsEXT] =
4172 for value in VkVideoEncodeH264CapabilityFlagBitsEXT.items:
4173 if (value.ord and cint(number)) > 0:
4174 result.add value
4175 proc `==`*(a, b: VkVideoEncodeH264CapabilityFlagsEXT): bool = cint(a) == cint(b)
4176 type
4177 VkVideoEncodeH264InputModeFlagBitsEXT* {.size: sizeof(cint).} = enum
4178 VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001
4179 VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0b00000000000000000000000000000010
4180 VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100
4181 func toBits*(flags: openArray[VkVideoEncodeH264InputModeFlagBitsEXT]): VkVideoEncodeH264InputModeFlagsEXT =
4182 for flag in flags:
4183 result = VkVideoEncodeH264InputModeFlagsEXT(uint(result) or uint(flag))
4184 func toEnums*(number: VkVideoEncodeH264InputModeFlagsEXT): seq[VkVideoEncodeH264InputModeFlagBitsEXT] =
4185 for value in VkVideoEncodeH264InputModeFlagBitsEXT.items:
4186 if (value.ord and cint(number)) > 0:
4187 result.add value
4188 proc `==`*(a, b: VkVideoEncodeH264InputModeFlagsEXT): bool = cint(a) == cint(b)
4189 type
4190 VkVideoEncodeH264OutputModeFlagBitsEXT* {.size: sizeof(cint).} = enum
4191 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001
4192 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0b00000000000000000000000000000010
4193 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100
4194 func toBits*(flags: openArray[VkVideoEncodeH264OutputModeFlagBitsEXT]): VkVideoEncodeH264OutputModeFlagsEXT =
4195 for flag in flags:
4196 result = VkVideoEncodeH264OutputModeFlagsEXT(uint(result) or uint(flag))
4197 func toEnums*(number: VkVideoEncodeH264OutputModeFlagsEXT): seq[VkVideoEncodeH264OutputModeFlagBitsEXT] =
4198 for value in VkVideoEncodeH264OutputModeFlagBitsEXT.items:
4199 if (value.ord and cint(number)) > 0:
4200 result.add value
4201 proc `==`*(a, b: VkVideoEncodeH264OutputModeFlagsEXT): bool = cint(a) == cint(b)
4202 type
4203 VkVideoEncodeH264RateControlStructureEXT* {.size: sizeof(cint).} = enum
4204 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0
4205 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1
4206 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2
4207 VkImageConstraintsInfoFlagBitsFUCHSIA* {.size: sizeof(cint).} = enum
4208 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0b00000000000000000000000000000001
4209 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0b00000000000000000000000000000010
4210 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0b00000000000000000000000000000100
4211 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0b00000000000000000000000000001000
4212 VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0b00000000000000000000000000010000
4213 func toBits*(flags: openArray[VkImageConstraintsInfoFlagBitsFUCHSIA]): VkImageConstraintsInfoFlagsFUCHSIA =
4214 for flag in flags:
4215 result = VkImageConstraintsInfoFlagsFUCHSIA(uint(result) or uint(flag))
4216 func toEnums*(number: VkImageConstraintsInfoFlagsFUCHSIA): seq[VkImageConstraintsInfoFlagBitsFUCHSIA] =
4217 for value in VkImageConstraintsInfoFlagBitsFUCHSIA.items:
4218 if (value.ord and cint(number)) > 0:
4219 result.add value
4220 proc `==`*(a, b: VkImageConstraintsInfoFlagsFUCHSIA): bool = cint(a) == cint(b)
4221 type
4222 VkFormatFeatureFlagBits2* {.size: 8.} = enum
4223 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0b0000000000000000000000000000000000000000000000000000000000000001
4224 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0b0000000000000000000000000000000000000000000000000000000000000010
4225 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0b0000000000000000000000000000000000000000000000000000000000000100
4226 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0b0000000000000000000000000000000000000000000000000000000000001000
4227 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0b0000000000000000000000000000000000000000000000000000000000010000
4228 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0b0000000000000000000000000000000000000000000000000000000000100000
4229 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0b0000000000000000000000000000000000000000000000000000000001000000
4230 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0b0000000000000000000000000000000000000000000000000000000010000000
4231 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0b0000000000000000000000000000000000000000000000000000000100000000
4232 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0b0000000000000000000000000000000000000000000000000000001000000000
4233 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0b0000000000000000000000000000000000000000000000000000010000000000
4234 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0b0000000000000000000000000000000000000000000000000000100000000000
4235 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0b0000000000000000000000000000000000000000000000000001000000000000
4236 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0b0000000000000000000000000000000000000000000000000010000000000000
4237 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0b0000000000000000000000000000000000000000000000000100000000000000
4238 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0b0000000000000000000000000000000000000000000000001000000000000000
4239 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0b0000000000000000000000000000000000000000000000010000000000000000
4240 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0b0000000000000000000000000000000000000000000000100000000000000000
4241 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0b0000000000000000000000000000000000000000000001000000000000000000
4242 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0b0000000000000000000000000000000000000000000010000000000000000000
4243 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0b0000000000000000000000000000000000000000000100000000000000000000
4244 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0b0000000000000000000000000000000000000000001000000000000000000000
4245 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0b0000000000000000000000000000000000000000010000000000000000000000
4246 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0b0000000000000000000000000000000000000000100000000000000000000000
4247 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0b0000000000000000000000000000000000000001000000000000000000000000
4248 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0b0000000000000000000000000000000000000010000000000000000000000000
4249 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0b0000000000000000000000000000000000000100000000000000000000000000
4250 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0b0000000000000000000000000000000000001000000000000000000000000000
4251 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0b0000000000000000000000000000000000010000000000000000000000000000
4252 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0b0000000000000000000000000000000000100000000000000000000000000000
4253 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b0000000000000000000000000000000001000000000000000000000000000000
4254 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0b0000000000000000000000000000000010000000000000000000000000000000
4255 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0b0000000000000000000000000000000100000000000000000000000000000000
4256 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0b0000000000000000000000000000001000000000000000000000000000000000
4257 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0b0000000000000000000000000000010000000000000000000000000000000000
4258 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0b0000000000000000000000000000100000000000000000000000000000000000
4259 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0b0000000000000000000000000001000000000000000000000000000000000000
4260 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0b0000000000000000000000000010000000000000000000000000000000000000
4261 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0b0000000000000000000000000100000000000000000000000000000000000000
4262 VK_FORMAT_FEATURE_2_RESERVED_39_BIT_EXT = 0b0000000000000000000000001000000000000000000000000000000000000000
4263 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0b0000000000000000000000010000000000000000000000000000000000000000
4264 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0b0000000000000000000000100000000000000000000000000000000000000000
4265 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0b0000000000000000000001000000000000000000000000000000000000000000
4266 VK_FORMAT_FEATURE_2_RESERVED_44_BIT_EXT = 0b0000000000000000000100000000000000000000000000000000000000000000
4267 VK_FORMAT_FEATURE_2_RESERVED_45_BIT_EXT = 0b0000000000000000001000000000000000000000000000000000000000000000
4268 func toBits*(flags: openArray[VkFormatFeatureFlagBits2]): VkFormatFeatureFlags2 =
4269 for flag in flags:
4270 result = VkFormatFeatureFlags2(uint64(result) or uint64(flag))
4271 func toEnums*(number: VkFormatFeatureFlags2): seq[VkFormatFeatureFlagBits2] =
4272 for value in VkFormatFeatureFlagBits2.items:
4273 if (cast[uint64](value) and uint64(number)) > 0:
4274 result.add value
4275 proc `==`*(a, b: VkFormatFeatureFlags2): bool = uint64(a) == uint64(b)
4276 type
4277 VkRenderingFlagBits* {.size: sizeof(cint).} = enum
4278 VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0b00000000000000000000000000000001
4279 VK_RENDERING_SUSPENDING_BIT = 0b00000000000000000000000000000010
4280 VK_RENDERING_RESUMING_BIT = 0b00000000000000000000000000000100
4281 VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0b00000000000000000000000000001000
4282 func toBits*(flags: openArray[VkRenderingFlagBits]): VkRenderingFlags =
4283 for flag in flags:
4284 result = VkRenderingFlags(uint(result) or uint(flag))
4285 func toEnums*(number: VkRenderingFlags): seq[VkRenderingFlagBits] =
4286 for value in VkRenderingFlagBits.items:
4287 if (value.ord and cint(number)) > 0:
4288 result.add value
4289 proc `==`*(a, b: VkRenderingFlags): bool = cint(a) == cint(b)
4290 type
4291 VkVideoEncodeH265CapabilityFlagBitsEXT* {.size: sizeof(cint).} = enum
4292 VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0b00000000000000000000000000000001
4293 VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0b00000000000000000000000000000010
4294 VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0b00000000000000000000000000000100
4295 VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0b00000000000000000000000000001000
4296 VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0b00000000000000000000000000010000
4297 VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0b00000000000000000000000000100000
4298 VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0b00000000000000000000000001000000
4299 VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0b00000000000000000000000010000000
4300 VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0b00000000000000000000000100000000
4301 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0b00000000000000000000001000000000
4302 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0b00000000000000000000010000000000
4303 VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0b00000000000000000000100000000000
4304 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0b00000000000000000001000000000000
4305 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0b00000000000000000010000000000000
4306 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0b00000000000000000100000000000000
4307 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0b00000000000000001000000000000000
4308 VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0b00000000000000010000000000000000
4309 VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0b00000000000000100000000000000000
4310 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0b00000000000001000000000000000000
4311 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0b00000000000010000000000000000000
4312 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0b00000000000100000000000000000000
4313 VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0b00000000001000000000000000000000
4314 VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0b00000000010000000000000000000000
4315 VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0b00000000100000000000000000000000
4316 VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0b00000001000000000000000000000000
4317 VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0b00000010000000000000000000000000
4318 func toBits*(flags: openArray[VkVideoEncodeH265CapabilityFlagBitsEXT]): VkVideoEncodeH265CapabilityFlagsEXT =
4319 for flag in flags:
4320 result = VkVideoEncodeH265CapabilityFlagsEXT(uint(result) or uint(flag))
4321 func toEnums*(number: VkVideoEncodeH265CapabilityFlagsEXT): seq[VkVideoEncodeH265CapabilityFlagBitsEXT] =
4322 for value in VkVideoEncodeH265CapabilityFlagBitsEXT.items:
4323 if (value.ord and cint(number)) > 0:
4324 result.add value
4325 proc `==`*(a, b: VkVideoEncodeH265CapabilityFlagsEXT): bool = cint(a) == cint(b)
4326 type
4327 VkVideoEncodeH265InputModeFlagBitsEXT* {.size: sizeof(cint).} = enum
4328 VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001
4329 VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0b00000000000000000000000000000010
4330 VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100
4331 func toBits*(flags: openArray[VkVideoEncodeH265InputModeFlagBitsEXT]): VkVideoEncodeH265InputModeFlagsEXT =
4332 for flag in flags:
4333 result = VkVideoEncodeH265InputModeFlagsEXT(uint(result) or uint(flag))
4334 func toEnums*(number: VkVideoEncodeH265InputModeFlagsEXT): seq[VkVideoEncodeH265InputModeFlagBitsEXT] =
4335 for value in VkVideoEncodeH265InputModeFlagBitsEXT.items:
4336 if (value.ord and cint(number)) > 0:
4337 result.add value
4338 proc `==`*(a, b: VkVideoEncodeH265InputModeFlagsEXT): bool = cint(a) == cint(b)
4339 type
4340 VkVideoEncodeH265OutputModeFlagBitsEXT* {.size: sizeof(cint).} = enum
4341 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001
4342 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0b00000000000000000000000000000010
4343 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100
4344 func toBits*(flags: openArray[VkVideoEncodeH265OutputModeFlagBitsEXT]): VkVideoEncodeH265OutputModeFlagsEXT =
4345 for flag in flags:
4346 result = VkVideoEncodeH265OutputModeFlagsEXT(uint(result) or uint(flag))
4347 func toEnums*(number: VkVideoEncodeH265OutputModeFlagsEXT): seq[VkVideoEncodeH265OutputModeFlagBitsEXT] =
4348 for value in VkVideoEncodeH265OutputModeFlagBitsEXT.items:
4349 if (value.ord and cint(number)) > 0:
4350 result.add value
4351 proc `==`*(a, b: VkVideoEncodeH265OutputModeFlagsEXT): bool = cint(a) == cint(b)
4352 type
4353 VkVideoEncodeH265RateControlStructureEXT* {.size: sizeof(cint).} = enum
4354 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0
4355 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1
4356 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2
4357 VkVideoEncodeH265CtbSizeFlagBitsEXT* {.size: sizeof(cint).} = enum
4358 VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0b00000000000000000000000000000001
4359 VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0b00000000000000000000000000000010
4360 VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0b00000000000000000000000000000100
4361 func toBits*(flags: openArray[VkVideoEncodeH265CtbSizeFlagBitsEXT]): VkVideoEncodeH265CtbSizeFlagsEXT =
4362 for flag in flags:
4363 result = VkVideoEncodeH265CtbSizeFlagsEXT(uint(result) or uint(flag))
4364 func toEnums*(number: VkVideoEncodeH265CtbSizeFlagsEXT): seq[VkVideoEncodeH265CtbSizeFlagBitsEXT] =
4365 for value in VkVideoEncodeH265CtbSizeFlagBitsEXT.items:
4366 if (value.ord and cint(number)) > 0:
4367 result.add value
4368 proc `==`*(a, b: VkVideoEncodeH265CtbSizeFlagsEXT): bool = cint(a) == cint(b)
4369 type
4370 VkVideoEncodeH265TransformBlockSizeFlagBitsEXT* {.size: sizeof(cint).} = enum
4371 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0b00000000000000000000000000000001
4372 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0b00000000000000000000000000000010
4373 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0b00000000000000000000000000000100
4374 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0b00000000000000000000000000001000
4375 func toBits*(flags: openArray[VkVideoEncodeH265TransformBlockSizeFlagBitsEXT]): VkVideoEncodeH265TransformBlockSizeFlagsEXT =
4376 for flag in flags:
4377 result = VkVideoEncodeH265TransformBlockSizeFlagsEXT(uint(result) or uint(flag))
4378 func toEnums*(number: VkVideoEncodeH265TransformBlockSizeFlagsEXT): seq[VkVideoEncodeH265TransformBlockSizeFlagBitsEXT] =
4379 for value in VkVideoEncodeH265TransformBlockSizeFlagBitsEXT.items:
4380 if (value.ord and cint(number)) > 0:
4381 result.add value
4382 proc `==`*(a, b: VkVideoEncodeH265TransformBlockSizeFlagsEXT): bool = cint(a) == cint(b)
4383 type
4384 VkExportMetalObjectTypeFlagBitsEXT* {.size: sizeof(cint).} = enum
4385 VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0b00000000000000000000000000000001
4386 VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0b00000000000000000000000000000010
4387 VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0b00000000000000000000000000000100
4388 VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0b00000000000000000000000000001000
4389 VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0b00000000000000000000000000010000
4390 VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0b00000000000000000000000000100000
4391 func toBits*(flags: openArray[VkExportMetalObjectTypeFlagBitsEXT]): VkExportMetalObjectTypeFlagsEXT =
4392 for flag in flags:
4393 result = VkExportMetalObjectTypeFlagsEXT(uint(result) or uint(flag))
4394 func toEnums*(number: VkExportMetalObjectTypeFlagsEXT): seq[VkExportMetalObjectTypeFlagBitsEXT] =
4395 for value in VkExportMetalObjectTypeFlagBitsEXT.items:
4396 if (value.ord and cint(number)) > 0:
4397 result.add value
4398 proc `==`*(a, b: VkExportMetalObjectTypeFlagsEXT): bool = cint(a) == cint(b)
4399 type
4400 VkInstanceCreateFlagBits* {.size: sizeof(cint).} = enum
4401 VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0b00000000000000000000000000000001
4402 func toBits*(flags: openArray[VkInstanceCreateFlagBits]): VkInstanceCreateFlags =
4403 for flag in flags:
4404 result = VkInstanceCreateFlags(uint(result) or uint(flag))
4405 func toEnums*(number: VkInstanceCreateFlags): seq[VkInstanceCreateFlagBits] =
4406 for value in VkInstanceCreateFlagBits.items:
4407 if (value.ord and cint(number)) > 0:
4408 result.add value
4409 proc `==`*(a, b: VkInstanceCreateFlags): bool = cint(a) == cint(b)
4410 type
4411 VkImageCompressionFlagBitsEXT* {.size: sizeof(cint).} = enum
4412 VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0b00000000000000000000000000000001
4413 VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0b00000000000000000000000000000010
4414 VK_IMAGE_COMPRESSION_DISABLED_EXT = 0b00000000000000000000000000000100
4415 func toBits*(flags: openArray[VkImageCompressionFlagBitsEXT]): VkImageCompressionFlagsEXT =
4416 for flag in flags:
4417 result = VkImageCompressionFlagsEXT(uint(result) or uint(flag))
4418 func toEnums*(number: VkImageCompressionFlagsEXT): seq[VkImageCompressionFlagBitsEXT] =
4419 for value in VkImageCompressionFlagBitsEXT.items:
4420 if (value.ord and cint(number)) > 0:
4421 result.add value
4422 proc `==`*(a, b: VkImageCompressionFlagsEXT): bool = cint(a) == cint(b)
4423 const
4424 VK_IMAGE_COMPRESSION_DEFAULT_EXT* = 0
4425 type
4426 VkImageCompressionFixedRateFlagBitsEXT* {.size: sizeof(cint).} = enum
4427 VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0b00000000000000000000000000000001
4428 VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0b00000000000000000000000000000010
4429 VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0b00000000000000000000000000000100
4430 VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0b00000000000000000000000000001000
4431 VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0b00000000000000000000000000010000
4432 VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0b00000000000000000000000000100000
4433 VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0b00000000000000000000000001000000
4434 VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0b00000000000000000000000010000000
4435 VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0b00000000000000000000000100000000
4436 VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0b00000000000000000000001000000000
4437 VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0b00000000000000000000010000000000
4438 VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0b00000000000000000000100000000000
4439 VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0b00000000000000000001000000000000
4440 VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0b00000000000000000010000000000000
4441 VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0b00000000000000000100000000000000
4442 VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0b00000000000000001000000000000000
4443 VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0b00000000000000010000000000000000
4444 VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0b00000000000000100000000000000000
4445 VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0b00000000000001000000000000000000
4446 VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0b00000000000010000000000000000000
4447 VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0b00000000000100000000000000000000
4448 VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0b00000000001000000000000000000000
4449 VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0b00000000010000000000000000000000
4450 VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0b00000000100000000000000000000000
4451 func toBits*(flags: openArray[VkImageCompressionFixedRateFlagBitsEXT]): VkImageCompressionFixedRateFlagsEXT =
4452 for flag in flags:
4453 result = VkImageCompressionFixedRateFlagsEXT(uint(result) or uint(flag))
4454 func toEnums*(number: VkImageCompressionFixedRateFlagsEXT): seq[VkImageCompressionFixedRateFlagBitsEXT] =
4455 for value in VkImageCompressionFixedRateFlagBitsEXT.items:
4456 if (value.ord and cint(number)) > 0:
4457 result.add value
4458 proc `==`*(a, b: VkImageCompressionFixedRateFlagsEXT): bool = cint(a) == cint(b)
4459 const
4460 VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT* = 0
4461 type
4462 VkPipelineRobustnessBufferBehaviorEXT* {.size: sizeof(cint).} = enum
4463 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0
4464 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1
4465 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2
4466 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3
4467 VkPipelineRobustnessImageBehaviorEXT* {.size: sizeof(cint).} = enum
4468 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0
4469 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1
4470 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2
4471 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3
4472 VkOpticalFlowGridSizeFlagBitsNV* {.size: sizeof(cint).} = enum
4473 VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0b00000000000000000000000000000001
4474 VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0b00000000000000000000000000000010
4475 VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0b00000000000000000000000000000100
4476 VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0b00000000000000000000000000001000
4477 func toBits*(flags: openArray[VkOpticalFlowGridSizeFlagBitsNV]): VkOpticalFlowGridSizeFlagsNV =
4478 for flag in flags:
4479 result = VkOpticalFlowGridSizeFlagsNV(uint(result) or uint(flag))
4480 func toEnums*(number: VkOpticalFlowGridSizeFlagsNV): seq[VkOpticalFlowGridSizeFlagBitsNV] =
4481 for value in VkOpticalFlowGridSizeFlagBitsNV.items:
4482 if (value.ord and cint(number)) > 0:
4483 result.add value
4484 proc `==`*(a, b: VkOpticalFlowGridSizeFlagsNV): bool = cint(a) == cint(b)
4485 const
4486 VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV* = 0
4487 type
4488 VkOpticalFlowUsageFlagBitsNV* {.size: sizeof(cint).} = enum
4489 VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0b00000000000000000000000000000001
4490 VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0b00000000000000000000000000000010
4491 VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0b00000000000000000000000000000100
4492 VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0b00000000000000000000000000001000
4493 VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0b00000000000000000000000000010000
4494 func toBits*(flags: openArray[VkOpticalFlowUsageFlagBitsNV]): VkOpticalFlowUsageFlagsNV =
4495 for flag in flags:
4496 result = VkOpticalFlowUsageFlagsNV(uint(result) or uint(flag))
4497 func toEnums*(number: VkOpticalFlowUsageFlagsNV): seq[VkOpticalFlowUsageFlagBitsNV] =
4498 for value in VkOpticalFlowUsageFlagBitsNV.items:
4499 if (value.ord and cint(number)) > 0:
4500 result.add value
4501 proc `==`*(a, b: VkOpticalFlowUsageFlagsNV): bool = cint(a) == cint(b)
4502 const
4503 VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV* = 0
4504 type
4505 VkOpticalFlowPerformanceLevelNV* {.size: sizeof(cint).} = enum
4506 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0
4507 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1
4508 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2
4509 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3
4510 VkOpticalFlowSessionBindingPointNV* {.size: sizeof(cint).} = enum
4511 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0
4512 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1
4513 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2
4514 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3
4515 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4
4516 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5
4517 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6
4518 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7
4519 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8
4520 VkOpticalFlowSessionCreateFlagBitsNV* {.size: sizeof(cint).} = enum
4521 VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0b00000000000000000000000000000001
4522 VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0b00000000000000000000000000000010
4523 VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0b00000000000000000000000000000100
4524 VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0b00000000000000000000000000001000
4525 VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0b00000000000000000000000000010000
4526 func toBits*(flags: openArray[VkOpticalFlowSessionCreateFlagBitsNV]): VkOpticalFlowSessionCreateFlagsNV =
4527 for flag in flags:
4528 result = VkOpticalFlowSessionCreateFlagsNV(uint(result) or uint(flag))
4529 func toEnums*(number: VkOpticalFlowSessionCreateFlagsNV): seq[VkOpticalFlowSessionCreateFlagBitsNV] =
4530 for value in VkOpticalFlowSessionCreateFlagBitsNV.items:
4531 if (value.ord and cint(number)) > 0:
4532 result.add value
4533 proc `==`*(a, b: VkOpticalFlowSessionCreateFlagsNV): bool = cint(a) == cint(b)
4534 type
4535 VkOpticalFlowExecuteFlagBitsNV* {.size: sizeof(cint).} = enum
4536 VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0b00000000000000000000000000000001
4537 func toBits*(flags: openArray[VkOpticalFlowExecuteFlagBitsNV]): VkOpticalFlowExecuteFlagsNV =
4538 for flag in flags:
4539 result = VkOpticalFlowExecuteFlagsNV(uint(result) or uint(flag))
4540 func toEnums*(number: VkOpticalFlowExecuteFlagsNV): seq[VkOpticalFlowExecuteFlagBitsNV] =
4541 for value in VkOpticalFlowExecuteFlagBitsNV.items:
4542 if (value.ord and cint(number)) > 0:
4543 result.add value
4544 proc `==`*(a, b: VkOpticalFlowExecuteFlagsNV): bool = cint(a) == cint(b)
4545 type
4546 VkMicromapTypeEXT* {.size: sizeof(cint).} = enum
4547 VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0
4548 VkBuildMicromapFlagBitsEXT* {.size: sizeof(cint).} = enum
4549 VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0b00000000000000000000000000000001
4550 VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0b00000000000000000000000000000010
4551 VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0b00000000000000000000000000000100
4552 func toBits*(flags: openArray[VkBuildMicromapFlagBitsEXT]): VkBuildMicromapFlagsEXT =
4553 for flag in flags:
4554 result = VkBuildMicromapFlagsEXT(uint(result) or uint(flag))
4555 func toEnums*(number: VkBuildMicromapFlagsEXT): seq[VkBuildMicromapFlagBitsEXT] =
4556 for value in VkBuildMicromapFlagBitsEXT.items:
4557 if (value.ord and cint(number)) > 0:
4558 result.add value
4559 proc `==`*(a, b: VkBuildMicromapFlagsEXT): bool = cint(a) == cint(b)
4560 type
4561 VkMicromapCreateFlagBitsEXT* {.size: sizeof(cint).} = enum
4562 VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000000001
4563 func toBits*(flags: openArray[VkMicromapCreateFlagBitsEXT]): VkMicromapCreateFlagsEXT =
4564 for flag in flags:
4565 result = VkMicromapCreateFlagsEXT(uint(result) or uint(flag))
4566 func toEnums*(number: VkMicromapCreateFlagsEXT): seq[VkMicromapCreateFlagBitsEXT] =
4567 for value in VkMicromapCreateFlagBitsEXT.items:
4568 if (value.ord and cint(number)) > 0:
4569 result.add value
4570 proc `==`*(a, b: VkMicromapCreateFlagsEXT): bool = cint(a) == cint(b)
4571 type
4572 VkCopyMicromapModeEXT* {.size: sizeof(cint).} = enum
4573 VK_COPY_MICROMAP_MODE_CLONE_EXT = 0
4574 VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1
4575 VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2
4576 VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3
4577 VkBuildMicromapModeEXT* {.size: sizeof(cint).} = enum
4578 VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0
4579 VkOpacityMicromapFormatEXT* {.size: sizeof(cint).} = enum
4580 VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1
4581 VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2
4582 VkOpacityMicromapSpecialIndexEXT* {.size: sizeof(cint).} = enum
4583 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4
4584 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3
4585 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2
4586 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1
4587 VkDeviceFaultAddressTypeEXT* {.size: sizeof(cint).} = enum
4588 VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0
4589 VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1
4590 VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2
4591 VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3
4592 VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4
4593 VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5
4594 VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6
4595 VkDeviceFaultVendorBinaryHeaderVersionEXT* {.size: sizeof(cint).} = enum
4596 VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT_ENUM = 1
4597 proc `$`*(bitset: VkFramebufferCreateFlags): string = $toEnums(bitset)
4598 proc `$`*(bitset: VkRenderPassCreateFlags): string = $toEnums(bitset)
4599 proc `$`*(bitset: VkSamplerCreateFlags): string = $toEnums(bitset)
4600 proc `$`*(bitset: VkPipelineCacheCreateFlags): string = $toEnums(bitset)
4601 proc `$`*(bitset: VkPipelineShaderStageCreateFlags): string = $toEnums(bitset)
4602 proc `$`*(bitset: VkDescriptorSetLayoutCreateFlags): string = $toEnums(bitset)
4603 proc `$`*(bitset: VkInstanceCreateFlags): string = $toEnums(bitset)
4604 proc `$`*(bitset: VkDeviceQueueCreateFlags): string = $toEnums(bitset)
4605 proc `$`*(bitset: VkBufferCreateFlags): string = $toEnums(bitset)
4606 proc `$`*(bitset: VkBufferUsageFlags): string = $toEnums(bitset)
4607 proc `$`*(bitset: VkColorComponentFlags): string = $toEnums(bitset)
4608 proc `$`*(bitset: VkCommandPoolCreateFlags): string = $toEnums(bitset)
4609 proc `$`*(bitset: VkCommandPoolResetFlags): string = $toEnums(bitset)
4610 proc `$`*(bitset: VkCommandBufferResetFlags): string = $toEnums(bitset)
4611 proc `$`*(bitset: VkCommandBufferUsageFlags): string = $toEnums(bitset)
4612 proc `$`*(bitset: VkCullModeFlags): string = $toEnums(bitset)
4613 proc `$`*(bitset: VkFenceCreateFlags): string = $toEnums(bitset)
4614 proc `$`*(bitset: VkFormatFeatureFlags): string = $toEnums(bitset)
4615 proc `$`*(bitset: VkImageAspectFlags): string = $toEnums(bitset)
4616 proc `$`*(bitset: VkImageCreateFlags): string = $toEnums(bitset)
4617 proc `$`*(bitset: VkImageUsageFlags): string = $toEnums(bitset)
4618 proc `$`*(bitset: VkImageViewCreateFlags): string = $toEnums(bitset)
4619 proc `$`*(bitset: VkMemoryHeapFlags): string = $toEnums(bitset)
4620 proc `$`*(bitset: VkAccessFlags): string = $toEnums(bitset)
4621 proc `$`*(bitset: VkMemoryPropertyFlags): string = $toEnums(bitset)
4622 proc `$`*(bitset: VkPipelineCreateFlags): string = $toEnums(bitset)
4623 proc `$`*(bitset: VkQueryControlFlags): string = $toEnums(bitset)
4624 proc `$`*(bitset: VkQueryPipelineStatisticFlags): string = $toEnums(bitset)
4625 proc `$`*(bitset: VkQueryResultFlags): string = $toEnums(bitset)
4626 proc `$`*(bitset: VkQueueFlags): string = $toEnums(bitset)
4627 proc `$`*(bitset: VkShaderStageFlags): string = $toEnums(bitset)
4628 proc `$`*(bitset: VkSparseMemoryBindFlags): string = $toEnums(bitset)
4629 proc `$`*(bitset: VkStencilFaceFlags): string = $toEnums(bitset)
4630 proc `$`*(bitset: VkPipelineStageFlags): string = $toEnums(bitset)
4631 proc `$`*(bitset: VkSparseImageFormatFlags): string = $toEnums(bitset)
4632 proc `$`*(bitset: VkSampleCountFlags): string = $toEnums(bitset)
4633 proc `$`*(bitset: VkAttachmentDescriptionFlags): string = $toEnums(bitset)
4634 proc `$`*(bitset: VkDescriptorPoolCreateFlags): string = $toEnums(bitset)
4635 proc `$`*(bitset: VkDependencyFlags): string = $toEnums(bitset)
4636 proc `$`*(bitset: VkEventCreateFlags): string = $toEnums(bitset)
4637 proc `$`*(bitset: VkPipelineLayoutCreateFlags): string = $toEnums(bitset)
4638 proc `$`*(bitset: VkIndirectCommandsLayoutUsageFlagsNV): string = $toEnums(bitset)
4639 proc `$`*(bitset: VkIndirectStateFlagsNV): string = $toEnums(bitset)
4640 proc `$`*(bitset: VkPrivateDataSlotCreateFlags): string = $toEnums(bitset)
4641 proc `$`*(bitset: VkSubpassDescriptionFlags): string = $toEnums(bitset)
4642 proc `$`*(bitset: VkResolveModeFlags): string = $toEnums(bitset)
4643 proc `$`*(bitset: VkDescriptorBindingFlags): string = $toEnums(bitset)
4644 proc `$`*(bitset: VkConditionalRenderingFlagsEXT): string = $toEnums(bitset)
4645 proc `$`*(bitset: VkGeometryFlagsKHR): string = $toEnums(bitset)
4646 proc `$`*(bitset: VkGeometryInstanceFlagsKHR): string = $toEnums(bitset)
4647 proc `$`*(bitset: VkBuildAccelerationStructureFlagsKHR): string = $toEnums(bitset)
4648 proc `$`*(bitset: VkAccelerationStructureCreateFlagsKHR): string = $toEnums(bitset)
4649 proc `$`*(bitset: VkDeviceDiagnosticsConfigFlagsNV): string = $toEnums(bitset)
4650 proc `$`*(bitset: VkPipelineCreationFeedbackFlags): string = $toEnums(bitset)
4651 proc `$`*(bitset: VkPerformanceCounterDescriptionFlagsKHR): string = $toEnums(bitset)
4652 proc `$`*(bitset: VkSemaphoreWaitFlags): string = $toEnums(bitset)
4653 proc `$`*(bitset: VkToolPurposeFlags): string = $toEnums(bitset)
4654 proc `$`*(bitset: VkAccessFlags2): string = $toEnums(bitset)
4655 proc `$`*(bitset: VkPipelineStageFlags2): string = $toEnums(bitset)
4656 proc `$`*(bitset: VkImageConstraintsInfoFlagsFUCHSIA): string = $toEnums(bitset)
4657 proc `$`*(bitset: VkFormatFeatureFlags2): string = $toEnums(bitset)
4658 proc `$`*(bitset: VkRenderingFlags): string = $toEnums(bitset)
4659 proc `$`*(bitset: VkPipelineDepthStencilStateCreateFlags): string = $toEnums(bitset)
4660 proc `$`*(bitset: VkPipelineColorBlendStateCreateFlags): string = $toEnums(bitset)
4661 proc `$`*(bitset: VkImageCompressionFlagsEXT): string = $toEnums(bitset)
4662 proc `$`*(bitset: VkImageCompressionFixedRateFlagsEXT): string = $toEnums(bitset)
4663 proc `$`*(bitset: VkExportMetalObjectTypeFlagsEXT): string = $toEnums(bitset)
4664 proc `$`*(bitset: VkDeviceAddressBindingFlagsEXT): string = $toEnums(bitset)
4665 proc `$`*(bitset: VkBuildMicromapFlagsEXT): string = $toEnums(bitset)
4666 proc `$`*(bitset: VkMicromapCreateFlagsEXT): string = $toEnums(bitset)
4667 proc `$`*(bitset: VkMemoryDecompressionMethodFlagsNV): string = $toEnums(bitset)
4668 proc `$`*(bitset: VkCompositeAlphaFlagsKHR): string = $toEnums(bitset)
4669 proc `$`*(bitset: VkDisplayPlaneAlphaFlagsKHR): string = $toEnums(bitset)
4670 proc `$`*(bitset: VkSurfaceTransformFlagsKHR): string = $toEnums(bitset)
4671 proc `$`*(bitset: VkDebugReportFlagsEXT): string = $toEnums(bitset)
4672 proc `$`*(bitset: VkExternalMemoryHandleTypeFlagsNV): string = $toEnums(bitset)
4673 proc `$`*(bitset: VkExternalMemoryFeatureFlagsNV): string = $toEnums(bitset)
4674 proc `$`*(bitset: VkExternalMemoryHandleTypeFlags): string = $toEnums(bitset)
4675 proc `$`*(bitset: VkExternalMemoryFeatureFlags): string = $toEnums(bitset)
4676 proc `$`*(bitset: VkExternalSemaphoreHandleTypeFlags): string = $toEnums(bitset)
4677 proc `$`*(bitset: VkExternalSemaphoreFeatureFlags): string = $toEnums(bitset)
4678 proc `$`*(bitset: VkSemaphoreImportFlags): string = $toEnums(bitset)
4679 proc `$`*(bitset: VkExternalFenceHandleTypeFlags): string = $toEnums(bitset)
4680 proc `$`*(bitset: VkExternalFenceFeatureFlags): string = $toEnums(bitset)
4681 proc `$`*(bitset: VkFenceImportFlags): string = $toEnums(bitset)
4682 proc `$`*(bitset: VkSurfaceCounterFlagsEXT): string = $toEnums(bitset)
4683 proc `$`*(bitset: VkPeerMemoryFeatureFlags): string = $toEnums(bitset)
4684 proc `$`*(bitset: VkMemoryAllocateFlags): string = $toEnums(bitset)
4685 proc `$`*(bitset: VkDeviceGroupPresentModeFlagsKHR): string = $toEnums(bitset)
4686 proc `$`*(bitset: VkSwapchainCreateFlagsKHR): string = $toEnums(bitset)
4687 proc `$`*(bitset: VkSubgroupFeatureFlags): string = $toEnums(bitset)
4688 proc `$`*(bitset: VkDebugUtilsMessageSeverityFlagsEXT): string = $toEnums(bitset)
4689 proc `$`*(bitset: VkDebugUtilsMessageTypeFlagsEXT): string = $toEnums(bitset)
4690 proc `$`*(bitset: VkSwapchainImageUsageFlagsANDROID): string = $toEnums(bitset)
4691 proc `$`*(bitset: VkSubmitFlags): string = $toEnums(bitset)
4692 proc `$`*(bitset: VkGraphicsPipelineLibraryFlagsEXT): string = $toEnums(bitset)
4693 proc `$`*(bitset: VkOpticalFlowGridSizeFlagsNV): string = $toEnums(bitset)
4694 proc `$`*(bitset: VkOpticalFlowUsageFlagsNV): string = $toEnums(bitset)
4695 proc `$`*(bitset: VkOpticalFlowSessionCreateFlagsNV): string = $toEnums(bitset)
4696 proc `$`*(bitset: VkOpticalFlowExecuteFlagsNV): string = $toEnums(bitset)
4697 proc `$`*(bitset: VkPresentScalingFlagsEXT): string = $toEnums(bitset)
4698 proc `$`*(bitset: VkPresentGravityFlagsEXT): string = $toEnums(bitset)
4699 proc `$`*(bitset: VkVideoCodecOperationFlagsKHR): string = $toEnums(bitset)
4700 proc `$`*(bitset: VkVideoChromaSubsamplingFlagsKHR): string = $toEnums(bitset)
4701 proc `$`*(bitset: VkVideoComponentBitDepthFlagsKHR): string = $toEnums(bitset)
4702 proc `$`*(bitset: VkVideoCapabilityFlagsKHR): string = $toEnums(bitset)
4703 proc `$`*(bitset: VkVideoSessionCreateFlagsKHR): string = $toEnums(bitset)
4704 proc `$`*(bitset: VkVideoCodingControlFlagsKHR): string = $toEnums(bitset)
4705 proc `$`*(bitset: VkVideoDecodeUsageFlagsKHR): string = $toEnums(bitset)
4706 proc `$`*(bitset: VkVideoDecodeCapabilityFlagsKHR): string = $toEnums(bitset)
4707 proc `$`*(bitset: VkVideoDecodeH264PictureLayoutFlagsKHR): string = $toEnums(bitset)
4708 proc `$`*(bitset: VkVideoEncodeUsageFlagsKHR): string = $toEnums(bitset)
4709 proc `$`*(bitset: VkVideoEncodeContentFlagsKHR): string = $toEnums(bitset)
4710 proc `$`*(bitset: VkVideoEncodeCapabilityFlagsKHR): string = $toEnums(bitset)
4711 proc `$`*(bitset: VkVideoEncodeRateControlModeFlagsKHR): string = $toEnums(bitset)
4712 proc `$`*(bitset: VkVideoEncodeH264CapabilityFlagsEXT): string = $toEnums(bitset)
4713 proc `$`*(bitset: VkVideoEncodeH264InputModeFlagsEXT): string = $toEnums(bitset)
4714 proc `$`*(bitset: VkVideoEncodeH264OutputModeFlagsEXT): string = $toEnums(bitset)
4715 proc `$`*(bitset: VkVideoEncodeH265CapabilityFlagsEXT): string = $toEnums(bitset)
4716 proc `$`*(bitset: VkVideoEncodeH265InputModeFlagsEXT): string = $toEnums(bitset)
4717 proc `$`*(bitset: VkVideoEncodeH265OutputModeFlagsEXT): string = $toEnums(bitset)
4718 proc `$`*(bitset: VkVideoEncodeH265CtbSizeFlagsEXT): string = $toEnums(bitset)
4719 proc `$`*(bitset: VkVideoEncodeH265TransformBlockSizeFlagsEXT): string = $toEnums(bitset)
4720 type
4721 VkGeometryFlagsNV* = VkGeometryFlagsKHR
4722 VkGeometryInstanceFlagsNV* = VkGeometryInstanceFlagsKHR
4723 VkBuildAccelerationStructureFlagsNV* = VkBuildAccelerationStructureFlagsKHR
4724 VkPrivateDataSlotCreateFlagsEXT* = VkPrivateDataSlotCreateFlags
4725 VkDescriptorUpdateTemplateCreateFlagsKHR* = VkDescriptorUpdateTemplateCreateFlags
4726 VkPipelineCreationFeedbackFlagsEXT* = VkPipelineCreationFeedbackFlags
4727 VkSemaphoreWaitFlagsKHR* = VkSemaphoreWaitFlags
4728 VkAccessFlags2KHR* = VkAccessFlags2
4729 VkPipelineStageFlags2KHR* = VkPipelineStageFlags2
4730 VkFormatFeatureFlags2KHR* = VkFormatFeatureFlags2
4731 VkRenderingFlagsKHR* = VkRenderingFlags
4732 VkPeerMemoryFeatureFlagsKHR* = VkPeerMemoryFeatureFlags
4733 VkMemoryAllocateFlagsKHR* = VkMemoryAllocateFlags
4734 VkCommandPoolTrimFlagsKHR* = VkCommandPoolTrimFlags
4735 VkExternalMemoryHandleTypeFlagsKHR* = VkExternalMemoryHandleTypeFlags
4736 VkExternalMemoryFeatureFlagsKHR* = VkExternalMemoryFeatureFlags
4737 VkExternalSemaphoreHandleTypeFlagsKHR* = VkExternalSemaphoreHandleTypeFlags
4738 VkExternalSemaphoreFeatureFlagsKHR* = VkExternalSemaphoreFeatureFlags
4739 VkSemaphoreImportFlagsKHR* = VkSemaphoreImportFlags
4740 VkExternalFenceHandleTypeFlagsKHR* = VkExternalFenceHandleTypeFlags
4741 VkExternalFenceFeatureFlagsKHR* = VkExternalFenceFeatureFlags
4742 VkFenceImportFlagsKHR* = VkFenceImportFlags
4743 VkDescriptorBindingFlagsEXT* = VkDescriptorBindingFlags
4744 VkResolveModeFlagsKHR* = VkResolveModeFlags
4745 VkToolPurposeFlagsEXT* = VkToolPurposeFlags
4746 VkSubmitFlagsKHR* = VkSubmitFlags
4747 VkPrivateDataSlotCreateFlagBitsEXT* = VkPrivateDataSlotCreateFlagBits
4748 VkDescriptorUpdateTemplateTypeKHR* = VkDescriptorUpdateTemplateType
4749 VkPointClippingBehaviorKHR* = VkPointClippingBehavior
4750 VkQueueGlobalPriorityEXT* = VkQueueGlobalPriorityKHR
4751 VkResolveModeFlagBitsKHR* = VkResolveModeFlagBits
4752 VkDescriptorBindingFlagBitsEXT* = VkDescriptorBindingFlagBits
4753 VkSemaphoreTypeKHR* = VkSemaphoreType
4754 VkGeometryFlagBitsNV* = VkGeometryFlagBitsKHR
4755 VkGeometryInstanceFlagBitsNV* = VkGeometryInstanceFlagBitsKHR
4756 VkBuildAccelerationStructureFlagBitsNV* = VkBuildAccelerationStructureFlagBitsKHR
4757 VkCopyAccelerationStructureModeNV* = VkCopyAccelerationStructureModeKHR
4758 VkAccelerationStructureTypeNV* = VkAccelerationStructureTypeKHR
4759 VkGeometryTypeNV* = VkGeometryTypeKHR
4760 VkRayTracingShaderGroupTypeNV* = VkRayTracingShaderGroupTypeKHR
4761 VkPipelineCreationFeedbackFlagBitsEXT* = VkPipelineCreationFeedbackFlagBits
4762 VkSemaphoreWaitFlagBitsKHR* = VkSemaphoreWaitFlagBits
4763 VkToolPurposeFlagBitsEXT* = VkToolPurposeFlagBits
4764 VkAccessFlagBits2KHR* = VkAccessFlagBits2
4765 VkPipelineStageFlagBits2KHR* = VkPipelineStageFlagBits2
4766 VkFormatFeatureFlagBits2KHR* = VkFormatFeatureFlagBits2
4767 VkRenderingFlagBitsKHR* = VkRenderingFlagBits
4768 VkExternalMemoryHandleTypeFlagBitsKHR* = VkExternalMemoryHandleTypeFlagBits
4769 VkExternalMemoryFeatureFlagBitsKHR* = VkExternalMemoryFeatureFlagBits
4770 VkExternalSemaphoreHandleTypeFlagBitsKHR* = VkExternalSemaphoreHandleTypeFlagBits
4771 VkExternalSemaphoreFeatureFlagBitsKHR* = VkExternalSemaphoreFeatureFlagBits
4772 VkSemaphoreImportFlagBitsKHR* = VkSemaphoreImportFlagBits
4773 VkExternalFenceHandleTypeFlagBitsKHR* = VkExternalFenceHandleTypeFlagBits
4774 VkExternalFenceFeatureFlagBitsKHR* = VkExternalFenceFeatureFlagBits
4775 VkFenceImportFlagBitsKHR* = VkFenceImportFlagBits
4776 VkPeerMemoryFeatureFlagBitsKHR* = VkPeerMemoryFeatureFlagBits
4777 VkMemoryAllocateFlagBitsKHR* = VkMemoryAllocateFlagBits
4778 VkTessellationDomainOriginKHR* = VkTessellationDomainOrigin
4779 VkSamplerYcbcrModelConversionKHR* = VkSamplerYcbcrModelConversion
4780 VkSamplerYcbcrRangeKHR* = VkSamplerYcbcrRange
4781 VkChromaLocationKHR* = VkChromaLocation
4782 VkSamplerReductionModeEXT* = VkSamplerReductionMode
4783 VkShaderFloatControlsIndependenceKHR* = VkShaderFloatControlsIndependence
4784 VkSubmitFlagBitsKHR* = VkSubmitFlagBits
4785 VkDriverIdKHR* = VkDriverId
4786 type
4787 PFN_vkInternalAllocationNotification* = proc(pUserData: pointer, size: csize_t, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope): void {.cdecl.}
4788 PFN_vkInternalFreeNotification* = proc(pUserData: pointer, size: csize_t, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope): void {.cdecl.}
4789 PFN_vkReallocationFunction* = proc(pUserData: pointer, pOriginal: pointer, size: csize_t, alignment: csize_t, allocationScope: VkSystemAllocationScope): pointer {.cdecl.}
4790 PFN_vkAllocationFunction* = proc(pUserData: pointer, size: csize_t, alignment: csize_t, allocationScope: VkSystemAllocationScope): pointer {.cdecl.}
4791 PFN_vkFreeFunction* = proc(pUserData: pointer, pMemory: pointer): void {.cdecl.}
4792 PFN_vkVoidFunction* = proc(): void {.cdecl.}
4793 PFN_vkDebugReportCallbackEXT* = proc(flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, theobject: uint64, location: csize_t, messageCode: int32, pLayerPrefix: cstring, pMessage: cstring, pUserData: pointer): VkBool32 {.cdecl.}
4794 PFN_vkDebugUtilsMessengerCallbackEXT* = proc(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT, pUserData: pointer): VkBool32 {.cdecl.}
4795 PFN_vkFaultCallbackFunction* = proc(unrecordedFaults: VkBool32, faultCount: uint32, pFaults: ptr VkFaultData): void {.cdecl.}
4796 PFN_vkDeviceMemoryReportCallbackEXT* = proc(pCallbackData: ptr VkDeviceMemoryReportCallbackDataEXT, pUserData: pointer): void {.cdecl.}
4797 PFN_vkGetInstanceProcAddrLUNARG* = proc(instance: VkInstance, pName: cstring): PFN_vkVoidFunction {.cdecl.}
4798 VkBaseOutStructure* = object
4799 sType*: VkStructureType
4800 pNext*: ptr VkBaseOutStructure
4801 VkBaseInStructure* = object
4802 sType*: VkStructureType
4803 pNext*: ptr VkBaseInStructure
4804 VkOffset2D* = object
4805 x*: int32
4806 y*: int32
4807 VkOffset3D* = object
4808 x*: int32
4809 y*: int32
4810 z*: int32
4811 VkExtent2D* = object
4812 width*: uint32
4813 height*: uint32
4814 VkExtent3D* = object
4815 width*: uint32
4816 height*: uint32
4817 depth*: uint32
4818 VkViewport* = object
4819 x*: float32
4820 y*: float32
4821 width*: float32
4822 height*: float32
4823 minDepth*: float32
4824 maxDepth*: float32
4825 VkRect2D* = object
4826 offset*: VkOffset2D
4827 extent*: VkExtent2D
4828 VkClearRect* = object
4829 rect*: VkRect2D
4830 baseArrayLayer*: uint32
4831 layerCount*: uint32
4832 VkComponentMapping* = object
4833 r*: VkComponentSwizzle
4834 g*: VkComponentSwizzle
4835 b*: VkComponentSwizzle
4836 a*: VkComponentSwizzle
4837 VkPhysicalDeviceProperties* = object
4838 apiVersion*: uint32
4839 driverVersion*: uint32
4840 vendorID*: uint32
4841 deviceID*: uint32
4842 deviceType*: VkPhysicalDeviceType
4843 deviceName*: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char]
4844 pipelineCacheUUID*: array[VK_UUID_SIZE, uint8]
4845 limits*: VkPhysicalDeviceLimits
4846 sparseProperties*: VkPhysicalDeviceSparseProperties
4847 VkExtensionProperties* = object
4848 extensionName*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
4849 specVersion*: uint32
4850 VkLayerProperties* = object
4851 layerName*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
4852 specVersion*: uint32
4853 implementationVersion*: uint32
4854 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
4855 VkApplicationInfo* = object
4856 sType*: VkStructureType
4857 pNext*: pointer
4858 pApplicationName*: cstring
4859 applicationVersion*: uint32
4860 pEngineName*: cstring
4861 engineVersion*: uint32
4862 apiVersion*: uint32
4863 VkAllocationCallbacks* = object
4864 pUserData*: pointer
4865 pfnAllocation*: PFN_vkAllocationFunction
4866 pfnReallocation*: PFN_vkReallocationFunction
4867 pfnFree*: PFN_vkFreeFunction
4868 pfnInternalAllocation*: PFN_vkInternalAllocationNotification
4869 pfnInternalFree*: PFN_vkInternalFreeNotification
4870 VkDeviceQueueCreateInfo* = object
4871 sType*: VkStructureType
4872 pNext*: pointer
4873 flags*: VkDeviceQueueCreateFlags
4874 queueFamilyIndex*: uint32
4875 queueCount*: uint32
4876 pQueuePriorities*: ptr float32
4877 VkDeviceCreateInfo* = object
4878 sType*: VkStructureType
4879 pNext*: pointer
4880 flags*: VkDeviceCreateFlags
4881 queueCreateInfoCount*: uint32
4882 pQueueCreateInfos*: ptr VkDeviceQueueCreateInfo
4883 enabledLayerCount*: uint32
4884 ppEnabledLayerNames*: cstringArray
4885 enabledExtensionCount*: uint32
4886 ppEnabledExtensionNames*: cstringArray
4887 pEnabledFeatures*: ptr VkPhysicalDeviceFeatures
4888 VkInstanceCreateInfo* = object
4889 sType*: VkStructureType
4890 pNext*: pointer
4891 flags*: VkInstanceCreateFlags
4892 pApplicationInfo*: ptr VkApplicationInfo
4893 enabledLayerCount*: uint32
4894 ppEnabledLayerNames*: cstringArray
4895 enabledExtensionCount*: uint32
4896 ppEnabledExtensionNames*: cstringArray
4897 VkQueueFamilyProperties* = object
4898 queueFlags*: VkQueueFlags
4899 queueCount*: uint32
4900 timestampValidBits*: uint32
4901 minImageTransferGranularity*: VkExtent3D
4902 VkPhysicalDeviceMemoryProperties* = object
4903 memoryTypeCount*: uint32
4904 memoryTypes*: array[VK_MAX_MEMORY_TYPES, VkMemoryType]
4905 memoryHeapCount*: uint32
4906 memoryHeaps*: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap]
4907 VkMemoryAllocateInfo* = object
4908 sType*: VkStructureType
4909 pNext*: pointer
4910 allocationSize*: VkDeviceSize
4911 memoryTypeIndex*: uint32
4912 VkMemoryRequirements* = object
4913 size*: VkDeviceSize
4914 alignment*: VkDeviceSize
4915 memoryTypeBits*: uint32
4916 VkSparseImageFormatProperties* = object
4917 aspectMask*: VkImageAspectFlags
4918 imageGranularity*: VkExtent3D
4919 flags*: VkSparseImageFormatFlags
4920 VkSparseImageMemoryRequirements* = object
4921 formatProperties*: VkSparseImageFormatProperties
4922 imageMipTailFirstLod*: uint32
4923 imageMipTailSize*: VkDeviceSize
4924 imageMipTailOffset*: VkDeviceSize
4925 imageMipTailStride*: VkDeviceSize
4926 VkMemoryType* = object
4927 propertyFlags*: VkMemoryPropertyFlags
4928 heapIndex*: uint32
4929 VkMemoryHeap* = object
4930 size*: VkDeviceSize
4931 flags*: VkMemoryHeapFlags
4932 VkMappedMemoryRange* = object
4933 sType*: VkStructureType
4934 pNext*: pointer
4935 memory*: VkDeviceMemory
4936 offset*: VkDeviceSize
4937 size*: VkDeviceSize
4938 VkFormatProperties* = object
4939 linearTilingFeatures*: VkFormatFeatureFlags
4940 optimalTilingFeatures*: VkFormatFeatureFlags
4941 bufferFeatures*: VkFormatFeatureFlags
4942 VkImageFormatProperties* = object
4943 maxExtent*: VkExtent3D
4944 maxMipLevels*: uint32
4945 maxArrayLayers*: uint32
4946 sampleCounts*: VkSampleCountFlags
4947 maxResourceSize*: VkDeviceSize
4948 VkDescriptorBufferInfo* = object
4949 buffer*: VkBuffer
4950 offset*: VkDeviceSize
4951 range*: VkDeviceSize
4952 VkDescriptorImageInfo* = object
4953 sampler*: VkSampler
4954 imageView*: VkImageView
4955 imageLayout*: VkImageLayout
4956 VkWriteDescriptorSet* = object
4957 sType*: VkStructureType
4958 pNext*: pointer
4959 dstSet*: VkDescriptorSet
4960 dstBinding*: uint32
4961 dstArrayElement*: uint32
4962 descriptorCount*: uint32
4963 descriptorType*: VkDescriptorType
4964 pImageInfo*: ptr VkDescriptorImageInfo
4965 pBufferInfo*: ptr VkDescriptorBufferInfo
4966 pTexelBufferView*: ptr VkBufferView
4967 VkCopyDescriptorSet* = object
4968 sType*: VkStructureType
4969 pNext*: pointer
4970 srcSet*: VkDescriptorSet
4971 srcBinding*: uint32
4972 srcArrayElement*: uint32
4973 dstSet*: VkDescriptorSet
4974 dstBinding*: uint32
4975 dstArrayElement*: uint32
4976 descriptorCount*: uint32
4977 VkBufferCreateInfo* = object
4978 sType*: VkStructureType
4979 pNext*: pointer
4980 flags*: VkBufferCreateFlags
4981 size*: VkDeviceSize
4982 usage*: VkBufferUsageFlags
4983 sharingMode*: VkSharingMode
4984 queueFamilyIndexCount*: uint32
4985 pQueueFamilyIndices*: ptr uint32
4986 VkBufferViewCreateInfo* = object
4987 sType*: VkStructureType
4988 pNext*: pointer
4989 flags*: VkBufferViewCreateFlags
4990 buffer*: VkBuffer
4991 format*: VkFormat
4992 offset*: VkDeviceSize
4993 range*: VkDeviceSize
4994 VkImageSubresource* = object
4995 aspectMask*: VkImageAspectFlags
4996 mipLevel*: uint32
4997 arrayLayer*: uint32
4998 VkImageSubresourceLayers* = object
4999 aspectMask*: VkImageAspectFlags
5000 mipLevel*: uint32
5001 baseArrayLayer*: uint32
5002 layerCount*: uint32
5003 VkImageSubresourceRange* = object
5004 aspectMask*: VkImageAspectFlags
5005 baseMipLevel*: uint32
5006 levelCount*: uint32
5007 baseArrayLayer*: uint32
5008 layerCount*: uint32
5009 VkMemoryBarrier* = object
5010 sType*: VkStructureType
5011 pNext*: pointer
5012 srcAccessMask*: VkAccessFlags
5013 dstAccessMask*: VkAccessFlags
5014 VkBufferMemoryBarrier* = object
5015 sType*: VkStructureType
5016 pNext*: pointer
5017 srcAccessMask*: VkAccessFlags
5018 dstAccessMask*: VkAccessFlags
5019 srcQueueFamilyIndex*: uint32
5020 dstQueueFamilyIndex*: uint32
5021 buffer*: VkBuffer
5022 offset*: VkDeviceSize
5023 size*: VkDeviceSize
5024 VkImageMemoryBarrier* = object
5025 sType*: VkStructureType
5026 pNext*: pointer
5027 srcAccessMask*: VkAccessFlags
5028 dstAccessMask*: VkAccessFlags
5029 oldLayout*: VkImageLayout
5030 newLayout*: VkImageLayout
5031 srcQueueFamilyIndex*: uint32
5032 dstQueueFamilyIndex*: uint32
5033 image*: VkImage
5034 subresourceRange*: VkImageSubresourceRange
5035 VkImageCreateInfo* = object
5036 sType*: VkStructureType
5037 pNext*: pointer
5038 flags*: VkImageCreateFlags
5039 imageType*: VkImageType
5040 format*: VkFormat
5041 extent*: VkExtent3D
5042 mipLevels*: uint32
5043 arrayLayers*: uint32
5044 samples*: VkSampleCountFlagBits
5045 tiling*: VkImageTiling
5046 usage*: VkImageUsageFlags
5047 sharingMode*: VkSharingMode
5048 queueFamilyIndexCount*: uint32
5049 pQueueFamilyIndices*: ptr uint32
5050 initialLayout*: VkImageLayout
5051 VkSubresourceLayout* = object
5052 offset*: VkDeviceSize
5053 size*: VkDeviceSize
5054 rowPitch*: VkDeviceSize
5055 arrayPitch*: VkDeviceSize
5056 depthPitch*: VkDeviceSize
5057 VkImageViewCreateInfo* = object
5058 sType*: VkStructureType
5059 pNext*: pointer
5060 flags*: VkImageViewCreateFlags
5061 image*: VkImage
5062 viewType*: VkImageViewType
5063 format*: VkFormat
5064 components*: VkComponentMapping
5065 subresourceRange*: VkImageSubresourceRange
5066 VkBufferCopy* = object
5067 srcOffset*: VkDeviceSize
5068 dstOffset*: VkDeviceSize
5069 size*: VkDeviceSize
5070 VkSparseMemoryBind* = object
5071 resourceOffset*: VkDeviceSize
5072 size*: VkDeviceSize
5073 memory*: VkDeviceMemory
5074 memoryOffset*: VkDeviceSize
5075 flags*: VkSparseMemoryBindFlags
5076 VkSparseImageMemoryBind* = object
5077 subresource*: VkImageSubresource
5078 offset*: VkOffset3D
5079 extent*: VkExtent3D
5080 memory*: VkDeviceMemory
5081 memoryOffset*: VkDeviceSize
5082 flags*: VkSparseMemoryBindFlags
5083 VkSparseBufferMemoryBindInfo* = object
5084 buffer*: VkBuffer
5085 bindCount*: uint32
5086 pBinds*: ptr VkSparseMemoryBind
5087 VkSparseImageOpaqueMemoryBindInfo* = object
5088 image*: VkImage
5089 bindCount*: uint32
5090 pBinds*: ptr VkSparseMemoryBind
5091 VkSparseImageMemoryBindInfo* = object
5092 image*: VkImage
5093 bindCount*: uint32
5094 pBinds*: ptr VkSparseImageMemoryBind
5095 VkBindSparseInfo* = object
5096 sType*: VkStructureType
5097 pNext*: pointer
5098 waitSemaphoreCount*: uint32
5099 pWaitSemaphores*: ptr VkSemaphore
5100 bufferBindCount*: uint32
5101 pBufferBinds*: ptr VkSparseBufferMemoryBindInfo
5102 imageOpaqueBindCount*: uint32
5103 pImageOpaqueBinds*: ptr VkSparseImageOpaqueMemoryBindInfo
5104 imageBindCount*: uint32
5105 pImageBinds*: ptr VkSparseImageMemoryBindInfo
5106 signalSemaphoreCount*: uint32
5107 pSignalSemaphores*: ptr VkSemaphore
5108 VkImageCopy* = object
5109 srcSubresource*: VkImageSubresourceLayers
5110 srcOffset*: VkOffset3D
5111 dstSubresource*: VkImageSubresourceLayers
5112 dstOffset*: VkOffset3D
5113 extent*: VkExtent3D
5114 VkImageBlit* = object
5115 srcSubresource*: VkImageSubresourceLayers
5116 srcOffsets*: array[2, VkOffset3D]
5117 dstSubresource*: VkImageSubresourceLayers
5118 dstOffsets*: array[2, VkOffset3D]
5119 VkBufferImageCopy* = object
5120 bufferOffset*: VkDeviceSize
5121 bufferRowLength*: uint32
5122 bufferImageHeight*: uint32
5123 imageSubresource*: VkImageSubresourceLayers
5124 imageOffset*: VkOffset3D
5125 imageExtent*: VkExtent3D
5126 VkCopyMemoryIndirectCommandNV* = object
5127 srcAddress*: VkDeviceAddress
5128 dstAddress*: VkDeviceAddress
5129 size*: VkDeviceSize
5130 VkCopyMemoryToImageIndirectCommandNV* = object
5131 srcAddress*: VkDeviceAddress
5132 bufferRowLength*: uint32
5133 bufferImageHeight*: uint32
5134 imageSubresource*: VkImageSubresourceLayers
5135 imageOffset*: VkOffset3D
5136 imageExtent*: VkExtent3D
5137 VkImageResolve* = object
5138 srcSubresource*: VkImageSubresourceLayers
5139 srcOffset*: VkOffset3D
5140 dstSubresource*: VkImageSubresourceLayers
5141 dstOffset*: VkOffset3D
5142 extent*: VkExtent3D
5143 VkShaderModuleCreateInfo* = object
5144 sType*: VkStructureType
5145 pNext*: pointer
5146 flags*: VkShaderModuleCreateFlags
5147 codeSize*: csize_t
5148 pCode*: ptr uint32
5149 VkDescriptorSetLayoutBinding* = object
5150 binding*: uint32
5151 descriptorType*: VkDescriptorType
5152 descriptorCount*: uint32
5153 stageFlags*: VkShaderStageFlags
5154 pImmutableSamplers*: ptr VkSampler
5155 VkDescriptorSetLayoutCreateInfo* = object
5156 sType*: VkStructureType
5157 pNext*: pointer
5158 flags*: VkDescriptorSetLayoutCreateFlags
5159 bindingCount*: uint32
5160 pBindings*: ptr VkDescriptorSetLayoutBinding
5161 VkDescriptorPoolSize* = object
5162 thetype*: VkDescriptorType
5163 descriptorCount*: uint32
5164 VkDescriptorPoolCreateInfo* = object
5165 sType*: VkStructureType
5166 pNext*: pointer
5167 flags*: VkDescriptorPoolCreateFlags
5168 maxSets*: uint32
5169 poolSizeCount*: uint32
5170 pPoolSizes*: ptr VkDescriptorPoolSize
5171 VkDescriptorSetAllocateInfo* = object
5172 sType*: VkStructureType
5173 pNext*: pointer
5174 descriptorPool*: VkDescriptorPool
5175 descriptorSetCount*: uint32
5176 pSetLayouts*: ptr VkDescriptorSetLayout
5177 VkSpecializationMapEntry* = object
5178 constantID*: uint32
5179 offset*: uint32
5180 size*: csize_t
5181 VkSpecializationInfo* = object
5182 mapEntryCount*: uint32
5183 pMapEntries*: ptr VkSpecializationMapEntry
5184 dataSize*: csize_t
5185 pData*: pointer
5186 VkPipelineShaderStageCreateInfo* = object
5187 sType*: VkStructureType
5188 pNext*: pointer
5189 flags*: VkPipelineShaderStageCreateFlags
5190 stage*: VkShaderStageFlagBits
5191 module*: VkShaderModule
5192 pName*: cstring
5193 pSpecializationInfo*: ptr VkSpecializationInfo
5194 VkComputePipelineCreateInfo* = object
5195 sType*: VkStructureType
5196 pNext*: pointer
5197 flags*: VkPipelineCreateFlags
5198 stage*: VkPipelineShaderStageCreateInfo
5199 layout*: VkPipelineLayout
5200 basePipelineHandle*: VkPipeline
5201 basePipelineIndex*: int32
5202 VkVertexInputBindingDescription* = object
5203 binding*: uint32
5204 stride*: uint32
5205 inputRate*: VkVertexInputRate
5206 VkVertexInputAttributeDescription* = object
5207 location*: uint32
5208 binding*: uint32
5209 format*: VkFormat
5210 offset*: uint32
5211 VkPipelineVertexInputStateCreateInfo* = object
5212 sType*: VkStructureType
5213 pNext*: pointer
5214 flags*: VkPipelineVertexInputStateCreateFlags
5215 vertexBindingDescriptionCount*: uint32
5216 pVertexBindingDescriptions*: ptr VkVertexInputBindingDescription
5217 vertexAttributeDescriptionCount*: uint32
5218 pVertexAttributeDescriptions*: ptr VkVertexInputAttributeDescription
5219 VkPipelineInputAssemblyStateCreateInfo* = object
5220 sType*: VkStructureType
5221 pNext*: pointer
5222 flags*: VkPipelineInputAssemblyStateCreateFlags
5223 topology*: VkPrimitiveTopology
5224 primitiveRestartEnable*: VkBool32
5225 VkPipelineTessellationStateCreateInfo* = object
5226 sType*: VkStructureType
5227 pNext*: pointer
5228 flags*: VkPipelineTessellationStateCreateFlags
5229 patchControlPoints*: uint32
5230 VkPipelineViewportStateCreateInfo* = object
5231 sType*: VkStructureType
5232 pNext*: pointer
5233 flags*: VkPipelineViewportStateCreateFlags
5234 viewportCount*: uint32
5235 pViewports*: ptr VkViewport
5236 scissorCount*: uint32
5237 pScissors*: ptr VkRect2D
5238 VkPipelineRasterizationStateCreateInfo* = object
5239 sType*: VkStructureType
5240 pNext*: pointer
5241 flags*: VkPipelineRasterizationStateCreateFlags
5242 depthClampEnable*: VkBool32
5243 rasterizerDiscardEnable*: VkBool32
5244 polygonMode*: VkPolygonMode
5245 cullMode*: VkCullModeFlags
5246 frontFace*: VkFrontFace
5247 depthBiasEnable*: VkBool32
5248 depthBiasConstantFactor*: float32
5249 depthBiasClamp*: float32
5250 depthBiasSlopeFactor*: float32
5251 lineWidth*: float32
5252 VkPipelineMultisampleStateCreateInfo* = object
5253 sType*: VkStructureType
5254 pNext*: pointer
5255 flags*: VkPipelineMultisampleStateCreateFlags
5256 rasterizationSamples*: VkSampleCountFlagBits
5257 sampleShadingEnable*: VkBool32
5258 minSampleShading*: float32
5259 pSampleMask*: ptr VkSampleMask
5260 alphaToCoverageEnable*: VkBool32
5261 alphaToOneEnable*: VkBool32
5262 VkPipelineColorBlendAttachmentState* = object
5263 blendEnable*: VkBool32
5264 srcColorBlendFactor*: VkBlendFactor
5265 dstColorBlendFactor*: VkBlendFactor
5266 colorBlendOp*: VkBlendOp
5267 srcAlphaBlendFactor*: VkBlendFactor
5268 dstAlphaBlendFactor*: VkBlendFactor
5269 alphaBlendOp*: VkBlendOp
5270 colorWriteMask*: VkColorComponentFlags
5271 VkPipelineColorBlendStateCreateInfo* = object
5272 sType*: VkStructureType
5273 pNext*: pointer
5274 flags*: VkPipelineColorBlendStateCreateFlags
5275 logicOpEnable*: VkBool32
5276 logicOp*: VkLogicOp
5277 attachmentCount*: uint32
5278 pAttachments*: ptr VkPipelineColorBlendAttachmentState
5279 blendConstants*: array[4, float32]
5280 VkPipelineDynamicStateCreateInfo* = object
5281 sType*: VkStructureType
5282 pNext*: pointer
5283 flags*: VkPipelineDynamicStateCreateFlags
5284 dynamicStateCount*: uint32
5285 pDynamicStates*: ptr VkDynamicState
5286 VkStencilOpState* = object
5287 failOp*: VkStencilOp
5288 passOp*: VkStencilOp
5289 depthFailOp*: VkStencilOp
5290 compareOp*: VkCompareOp
5291 compareMask*: uint32
5292 writeMask*: uint32
5293 reference*: uint32
5294 VkPipelineDepthStencilStateCreateInfo* = object
5295 sType*: VkStructureType
5296 pNext*: pointer
5297 flags*: VkPipelineDepthStencilStateCreateFlags
5298 depthTestEnable*: VkBool32
5299 depthWriteEnable*: VkBool32
5300 depthCompareOp*: VkCompareOp
5301 depthBoundsTestEnable*: VkBool32
5302 stencilTestEnable*: VkBool32
5303 front*: VkStencilOpState
5304 back*: VkStencilOpState
5305 minDepthBounds*: float32
5306 maxDepthBounds*: float32
5307 VkGraphicsPipelineCreateInfo* = object
5308 sType*: VkStructureType
5309 pNext*: pointer
5310 flags*: VkPipelineCreateFlags
5311 stageCount*: uint32
5312 pStages*: ptr VkPipelineShaderStageCreateInfo
5313 pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo
5314 pInputAssemblyState*: ptr VkPipelineInputAssemblyStateCreateInfo
5315 pTessellationState*: ptr VkPipelineTessellationStateCreateInfo
5316 pViewportState*: ptr VkPipelineViewportStateCreateInfo
5317 pRasterizationState*: ptr VkPipelineRasterizationStateCreateInfo
5318 pMultisampleState*: ptr VkPipelineMultisampleStateCreateInfo
5319 pDepthStencilState*: ptr VkPipelineDepthStencilStateCreateInfo
5320 pColorBlendState*: ptr VkPipelineColorBlendStateCreateInfo
5321 pDynamicState*: ptr VkPipelineDynamicStateCreateInfo
5322 layout*: VkPipelineLayout
5323 renderPass*: VkRenderPass
5324 subpass*: uint32
5325 basePipelineHandle*: VkPipeline
5326 basePipelineIndex*: int32
5327 VkPipelineCacheCreateInfo* = object
5328 sType*: VkStructureType
5329 pNext*: pointer
5330 flags*: VkPipelineCacheCreateFlags
5331 initialDataSize*: csize_t
5332 pInitialData*: pointer
5333 VkPipelineCacheHeaderVersionOne* = object
5334 headerSize*: uint32
5335 headerVersion*: VkPipelineCacheHeaderVersion
5336 vendorID*: uint32
5337 deviceID*: uint32
5338 pipelineCacheUUID*: array[VK_UUID_SIZE, uint8]
5339 VkPipelineCacheStageValidationIndexEntry* = object
5340 codeSize*: uint64
5341 codeOffset*: uint64
5342 VkPipelineCacheSafetyCriticalIndexEntry* = object
5343 pipelineIdentifier*: array[VK_UUID_SIZE, uint8]
5344 pipelineMemorySize*: uint64
5345 jsonSize*: uint64
5346 jsonOffset*: uint64
5347 stageIndexCount*: uint32
5348 stageIndexStride*: uint32
5349 stageIndexOffset*: uint64
5350 VkPipelineCacheHeaderVersionSafetyCriticalOne* = object
5351 headerVersionOne*: VkPipelineCacheHeaderVersionOne
5352 validationVersion*: VkPipelineCacheValidationVersion
5353 implementationData*: uint32
5354 pipelineIndexCount*: uint32
5355 pipelineIndexStride*: uint32
5356 pipelineIndexOffset*: uint64
5357 VkPushConstantRange* = object
5358 stageFlags*: VkShaderStageFlags
5359 offset*: uint32
5360 size*: uint32
5361 VkPipelineLayoutCreateInfo* = object
5362 sType*: VkStructureType
5363 pNext*: pointer
5364 flags*: VkPipelineLayoutCreateFlags
5365 setLayoutCount*: uint32
5366 pSetLayouts*: ptr VkDescriptorSetLayout
5367 pushConstantRangeCount*: uint32
5368 pPushConstantRanges*: ptr VkPushConstantRange
5369 VkSamplerCreateInfo* = object
5370 sType*: VkStructureType
5371 pNext*: pointer
5372 flags*: VkSamplerCreateFlags
5373 magFilter*: VkFilter
5374 minFilter*: VkFilter
5375 mipmapMode*: VkSamplerMipmapMode
5376 addressModeU*: VkSamplerAddressMode
5377 addressModeV*: VkSamplerAddressMode
5378 addressModeW*: VkSamplerAddressMode
5379 mipLodBias*: float32
5380 anisotropyEnable*: VkBool32
5381 maxAnisotropy*: float32
5382 compareEnable*: VkBool32
5383 compareOp*: VkCompareOp
5384 minLod*: float32
5385 maxLod*: float32
5386 borderColor*: VkBorderColor
5387 unnormalizedCoordinates*: VkBool32
5388 VkCommandPoolCreateInfo* = object
5389 sType*: VkStructureType
5390 pNext*: pointer
5391 flags*: VkCommandPoolCreateFlags
5392 queueFamilyIndex*: uint32
5393 VkCommandBufferAllocateInfo* = object
5394 sType*: VkStructureType
5395 pNext*: pointer
5396 commandPool*: VkCommandPool
5397 level*: VkCommandBufferLevel
5398 commandBufferCount*: uint32
5399 VkCommandBufferInheritanceInfo* = object
5400 sType*: VkStructureType
5401 pNext*: pointer
5402 renderPass*: VkRenderPass
5403 subpass*: uint32
5404 framebuffer*: VkFramebuffer
5405 occlusionQueryEnable*: VkBool32
5406 queryFlags*: VkQueryControlFlags
5407 pipelineStatistics*: VkQueryPipelineStatisticFlags
5408 VkCommandBufferBeginInfo* = object
5409 sType*: VkStructureType
5410 pNext*: pointer
5411 flags*: VkCommandBufferUsageFlags
5412 pInheritanceInfo*: ptr VkCommandBufferInheritanceInfo
5413 VkRenderPassBeginInfo* = object
5414 sType*: VkStructureType
5415 pNext*: pointer
5416 renderPass*: VkRenderPass
5417 framebuffer*: VkFramebuffer
5418 renderArea*: VkRect2D
5419 clearValueCount*: uint32
5420 pClearValues*: ptr VkClearValue
5421 VkClearColorValue* {.union.} = object
5422 float32*: array[4, float32]
5423 int32*: array[4, int32]
5424 uint32*: array[4, uint32]
5425 VkClearDepthStencilValue* = object
5426 depth*: float32
5427 stencil*: uint32
5428 VkClearValue* {.union.} = object
5429 color*: VkClearColorValue
5430 depthStencil*: VkClearDepthStencilValue
5431 VkClearAttachment* = object
5432 aspectMask*: VkImageAspectFlags
5433 colorAttachment*: uint32
5434 clearValue*: VkClearValue
5435 VkAttachmentDescription* = object
5436 flags*: VkAttachmentDescriptionFlags
5437 format*: VkFormat
5438 samples*: VkSampleCountFlagBits
5439 loadOp*: VkAttachmentLoadOp
5440 storeOp*: VkAttachmentStoreOp
5441 stencilLoadOp*: VkAttachmentLoadOp
5442 stencilStoreOp*: VkAttachmentStoreOp
5443 initialLayout*: VkImageLayout
5444 finalLayout*: VkImageLayout
5445 VkAttachmentReference* = object
5446 attachment*: uint32
5447 layout*: VkImageLayout
5448 VkSubpassDescription* = object
5449 flags*: VkSubpassDescriptionFlags
5450 pipelineBindPoint*: VkPipelineBindPoint
5451 inputAttachmentCount*: uint32
5452 pInputAttachments*: ptr VkAttachmentReference
5453 colorAttachmentCount*: uint32
5454 pColorAttachments*: ptr VkAttachmentReference
5455 pResolveAttachments*: ptr VkAttachmentReference
5456 pDepthStencilAttachment*: ptr VkAttachmentReference
5457 preserveAttachmentCount*: uint32
5458 pPreserveAttachments*: ptr uint32
5459 VkSubpassDependency* = object
5460 srcSubpass*: uint32
5461 dstSubpass*: uint32
5462 srcStageMask*: VkPipelineStageFlags
5463 dstStageMask*: VkPipelineStageFlags
5464 srcAccessMask*: VkAccessFlags
5465 dstAccessMask*: VkAccessFlags
5466 dependencyFlags*: VkDependencyFlags
5467 VkRenderPassCreateInfo* = object
5468 sType*: VkStructureType
5469 pNext*: pointer
5470 flags*: VkRenderPassCreateFlags
5471 attachmentCount*: uint32
5472 pAttachments*: ptr VkAttachmentDescription
5473 subpassCount*: uint32
5474 pSubpasses*: ptr VkSubpassDescription
5475 dependencyCount*: uint32
5476 pDependencies*: ptr VkSubpassDependency
5477 VkEventCreateInfo* = object
5478 sType*: VkStructureType
5479 pNext*: pointer
5480 flags*: VkEventCreateFlags
5481 VkFenceCreateInfo* = object
5482 sType*: VkStructureType
5483 pNext*: pointer
5484 flags*: VkFenceCreateFlags
5485 VkPhysicalDeviceFeatures* = object
5486 robustBufferAccess*: VkBool32
5487 fullDrawIndexUint32*: VkBool32
5488 imageCubeArray*: VkBool32
5489 independentBlend*: VkBool32
5490 geometryShader*: VkBool32
5491 tessellationShader*: VkBool32
5492 sampleRateShading*: VkBool32
5493 dualSrcBlend*: VkBool32
5494 logicOp*: VkBool32
5495 multiDrawIndirect*: VkBool32
5496 drawIndirectFirstInstance*: VkBool32
5497 depthClamp*: VkBool32
5498 depthBiasClamp*: VkBool32
5499 fillModeNonSolid*: VkBool32
5500 depthBounds*: VkBool32
5501 wideLines*: VkBool32
5502 largePoints*: VkBool32
5503 alphaToOne*: VkBool32
5504 multiViewport*: VkBool32
5505 samplerAnisotropy*: VkBool32
5506 textureCompressionETC2*: VkBool32
5507 textureCompressionASTC_LDR*: VkBool32
5508 textureCompressionBC*: VkBool32
5509 occlusionQueryPrecise*: VkBool32
5510 pipelineStatisticsQuery*: VkBool32
5511 vertexPipelineStoresAndAtomics*: VkBool32
5512 fragmentStoresAndAtomics*: VkBool32
5513 shaderTessellationAndGeometryPointSize*: VkBool32
5514 shaderImageGatherExtended*: VkBool32
5515 shaderStorageImageExtendedFormats*: VkBool32
5516 shaderStorageImageMultisample*: VkBool32
5517 shaderStorageImageReadWithoutFormat*: VkBool32
5518 shaderStorageImageWriteWithoutFormat*: VkBool32
5519 shaderUniformBufferArrayDynamicIndexing*: VkBool32
5520 shaderSampledImageArrayDynamicIndexing*: VkBool32
5521 shaderStorageBufferArrayDynamicIndexing*: VkBool32
5522 shaderStorageImageArrayDynamicIndexing*: VkBool32
5523 shaderClipDistance*: VkBool32
5524 shaderCullDistance*: VkBool32
5525 shaderFloat64*: VkBool32
5526 shaderInt64*: VkBool32
5527 shaderInt16*: VkBool32
5528 shaderResourceResidency*: VkBool32
5529 shaderResourceMinLod*: VkBool32
5530 sparseBinding*: VkBool32
5531 sparseResidencyBuffer*: VkBool32
5532 sparseResidencyImage2D*: VkBool32
5533 sparseResidencyImage3D*: VkBool32
5534 sparseResidency2Samples*: VkBool32
5535 sparseResidency4Samples*: VkBool32
5536 sparseResidency8Samples*: VkBool32
5537 sparseResidency16Samples*: VkBool32
5538 sparseResidencyAliased*: VkBool32
5539 variableMultisampleRate*: VkBool32
5540 inheritedQueries*: VkBool32
5541 VkPhysicalDeviceSparseProperties* = object
5542 residencyStandard2DBlockShape*: VkBool32
5543 residencyStandard2DMultisampleBlockShape*: VkBool32
5544 residencyStandard3DBlockShape*: VkBool32
5545 residencyAlignedMipSize*: VkBool32
5546 residencyNonResidentStrict*: VkBool32
5547 VkPhysicalDeviceLimits* = object
5548 maxImageDimension1D*: uint32
5549 maxImageDimension2D*: uint32
5550 maxImageDimension3D*: uint32
5551 maxImageDimensionCube*: uint32
5552 maxImageArrayLayers*: uint32
5553 maxTexelBufferElements*: uint32
5554 maxUniformBufferRange*: uint32
5555 maxStorageBufferRange*: uint32
5556 maxPushConstantsSize*: uint32
5557 maxMemoryAllocationCount*: uint32
5558 maxSamplerAllocationCount*: uint32
5559 bufferImageGranularity*: VkDeviceSize
5560 sparseAddressSpaceSize*: VkDeviceSize
5561 maxBoundDescriptorSets*: uint32
5562 maxPerStageDescriptorSamplers*: uint32
5563 maxPerStageDescriptorUniformBuffers*: uint32
5564 maxPerStageDescriptorStorageBuffers*: uint32
5565 maxPerStageDescriptorSampledImages*: uint32
5566 maxPerStageDescriptorStorageImages*: uint32
5567 maxPerStageDescriptorInputAttachments*: uint32
5568 maxPerStageResources*: uint32
5569 maxDescriptorSetSamplers*: uint32
5570 maxDescriptorSetUniformBuffers*: uint32
5571 maxDescriptorSetUniformBuffersDynamic*: uint32
5572 maxDescriptorSetStorageBuffers*: uint32
5573 maxDescriptorSetStorageBuffersDynamic*: uint32
5574 maxDescriptorSetSampledImages*: uint32
5575 maxDescriptorSetStorageImages*: uint32
5576 maxDescriptorSetInputAttachments*: uint32
5577 maxVertexInputAttributes*: uint32
5578 maxVertexInputBindings*: uint32
5579 maxVertexInputAttributeOffset*: uint32
5580 maxVertexInputBindingStride*: uint32
5581 maxVertexOutputComponents*: uint32
5582 maxTessellationGenerationLevel*: uint32
5583 maxTessellationPatchSize*: uint32
5584 maxTessellationControlPerVertexInputComponents*: uint32
5585 maxTessellationControlPerVertexOutputComponents*: uint32
5586 maxTessellationControlPerPatchOutputComponents*: uint32
5587 maxTessellationControlTotalOutputComponents*: uint32
5588 maxTessellationEvaluationInputComponents*: uint32
5589 maxTessellationEvaluationOutputComponents*: uint32
5590 maxGeometryShaderInvocations*: uint32
5591 maxGeometryInputComponents*: uint32
5592 maxGeometryOutputComponents*: uint32
5593 maxGeometryOutputVertices*: uint32
5594 maxGeometryTotalOutputComponents*: uint32
5595 maxFragmentInputComponents*: uint32
5596 maxFragmentOutputAttachments*: uint32
5597 maxFragmentDualSrcAttachments*: uint32
5598 maxFragmentCombinedOutputResources*: uint32
5599 maxComputeSharedMemorySize*: uint32
5600 maxComputeWorkGroupCount*: array[3, uint32]
5601 maxComputeWorkGroupInvocations*: uint32
5602 maxComputeWorkGroupSize*: array[3, uint32]
5603 subPixelPrecisionBits*: uint32
5604 subTexelPrecisionBits*: uint32
5605 mipmapPrecisionBits*: uint32
5606 maxDrawIndexedIndexValue*: uint32
5607 maxDrawIndirectCount*: uint32
5608 maxSamplerLodBias*: float32
5609 maxSamplerAnisotropy*: float32
5610 maxViewports*: uint32
5611 maxViewportDimensions*: array[2, uint32]
5612 viewportBoundsRange*: array[2, float32]
5613 viewportSubPixelBits*: uint32
5614 minMemoryMapAlignment*: csize_t
5615 minTexelBufferOffsetAlignment*: VkDeviceSize
5616 minUniformBufferOffsetAlignment*: VkDeviceSize
5617 minStorageBufferOffsetAlignment*: VkDeviceSize
5618 minTexelOffset*: int32
5619 maxTexelOffset*: uint32
5620 minTexelGatherOffset*: int32
5621 maxTexelGatherOffset*: uint32
5622 minInterpolationOffset*: float32
5623 maxInterpolationOffset*: float32
5624 subPixelInterpolationOffsetBits*: uint32
5625 maxFramebufferWidth*: uint32
5626 maxFramebufferHeight*: uint32
5627 maxFramebufferLayers*: uint32
5628 framebufferColorSampleCounts*: VkSampleCountFlags
5629 framebufferDepthSampleCounts*: VkSampleCountFlags
5630 framebufferStencilSampleCounts*: VkSampleCountFlags
5631 framebufferNoAttachmentsSampleCounts*: VkSampleCountFlags
5632 maxColorAttachments*: uint32
5633 sampledImageColorSampleCounts*: VkSampleCountFlags
5634 sampledImageIntegerSampleCounts*: VkSampleCountFlags
5635 sampledImageDepthSampleCounts*: VkSampleCountFlags
5636 sampledImageStencilSampleCounts*: VkSampleCountFlags
5637 storageImageSampleCounts*: VkSampleCountFlags
5638 maxSampleMaskWords*: uint32
5639 timestampComputeAndGraphics*: VkBool32
5640 timestampPeriod*: float32
5641 maxClipDistances*: uint32
5642 maxCullDistances*: uint32
5643 maxCombinedClipAndCullDistances*: uint32
5644 discreteQueuePriorities*: uint32
5645 pointSizeRange*: array[2, float32]
5646 lineWidthRange*: array[2, float32]
5647 pointSizeGranularity*: float32
5648 lineWidthGranularity*: float32
5649 strictLines*: VkBool32
5650 standardSampleLocations*: VkBool32
5651 optimalBufferCopyOffsetAlignment*: VkDeviceSize
5652 optimalBufferCopyRowPitchAlignment*: VkDeviceSize
5653 nonCoherentAtomSize*: VkDeviceSize
5654 VkSemaphoreCreateInfo* = object
5655 sType*: VkStructureType
5656 pNext*: pointer
5657 flags*: VkSemaphoreCreateFlags
5658 VkQueryPoolCreateInfo* = object
5659 sType*: VkStructureType
5660 pNext*: pointer
5661 flags*: VkQueryPoolCreateFlags
5662 queryType*: VkQueryType
5663 queryCount*: uint32
5664 pipelineStatistics*: VkQueryPipelineStatisticFlags
5665 VkFramebufferCreateInfo* = object
5666 sType*: VkStructureType
5667 pNext*: pointer
5668 flags*: VkFramebufferCreateFlags
5669 renderPass*: VkRenderPass
5670 attachmentCount*: uint32
5671 pAttachments*: ptr VkImageView
5672 width*: uint32
5673 height*: uint32
5674 layers*: uint32
5675 VkDrawIndirectCommand* = object
5676 vertexCount*: uint32
5677 instanceCount*: uint32
5678 firstVertex*: uint32
5679 firstInstance*: uint32
5680 VkDrawIndexedIndirectCommand* = object
5681 indexCount*: uint32
5682 instanceCount*: uint32
5683 firstIndex*: uint32
5684 vertexOffset*: int32
5685 firstInstance*: uint32
5686 VkDispatchIndirectCommand* = object
5687 x*: uint32
5688 y*: uint32
5689 z*: uint32
5690 VkMultiDrawInfoEXT* = object
5691 firstVertex*: uint32
5692 vertexCount*: uint32
5693 VkMultiDrawIndexedInfoEXT* = object
5694 firstIndex*: uint32
5695 indexCount*: uint32
5696 vertexOffset*: int32
5697 VkSubmitInfo* = object
5698 sType*: VkStructureType
5699 pNext*: pointer
5700 waitSemaphoreCount*: uint32
5701 pWaitSemaphores*: ptr VkSemaphore
5702 pWaitDstStageMask*: ptr VkPipelineStageFlags
5703 commandBufferCount*: uint32
5704 pCommandBuffers*: ptr VkCommandBuffer
5705 signalSemaphoreCount*: uint32
5706 pSignalSemaphores*: ptr VkSemaphore
5707 VkDisplayPropertiesKHR* = object
5708 display*: VkDisplayKHR
5709 displayName*: cstring
5710 physicalDimensions*: VkExtent2D
5711 physicalResolution*: VkExtent2D
5712 supportedTransforms*: VkSurfaceTransformFlagsKHR
5713 planeReorderPossible*: VkBool32
5714 persistentContent*: VkBool32
5715 VkDisplayPlanePropertiesKHR* = object
5716 currentDisplay*: VkDisplayKHR
5717 currentStackIndex*: uint32
5718 VkDisplayModeParametersKHR* = object
5719 visibleRegion*: VkExtent2D
5720 refreshRate*: uint32
5721 VkDisplayModePropertiesKHR* = object
5722 displayMode*: VkDisplayModeKHR
5723 parameters*: VkDisplayModeParametersKHR
5724 VkDisplayModeCreateInfoKHR* = object
5725 sType*: VkStructureType
5726 pNext*: pointer
5727 flags*: VkDisplayModeCreateFlagsKHR
5728 parameters*: VkDisplayModeParametersKHR
5729 VkDisplayPlaneCapabilitiesKHR* = object
5730 supportedAlpha*: VkDisplayPlaneAlphaFlagsKHR
5731 minSrcPosition*: VkOffset2D
5732 maxSrcPosition*: VkOffset2D
5733 minSrcExtent*: VkExtent2D
5734 maxSrcExtent*: VkExtent2D
5735 minDstPosition*: VkOffset2D
5736 maxDstPosition*: VkOffset2D
5737 minDstExtent*: VkExtent2D
5738 maxDstExtent*: VkExtent2D
5739 VkDisplaySurfaceCreateInfoKHR* = object
5740 sType*: VkStructureType
5741 pNext*: pointer
5742 flags*: VkDisplaySurfaceCreateFlagsKHR
5743 displayMode*: VkDisplayModeKHR
5744 planeIndex*: uint32
5745 planeStackIndex*: uint32
5746 transform*: VkSurfaceTransformFlagBitsKHR
5747 globalAlpha*: float32
5748 alphaMode*: VkDisplayPlaneAlphaFlagBitsKHR
5749 imageExtent*: VkExtent2D
5750 VkDisplayPresentInfoKHR* = object
5751 sType*: VkStructureType
5752 pNext*: pointer
5753 srcRect*: VkRect2D
5754 dstRect*: VkRect2D
5755 persistent*: VkBool32
5756 VkSurfaceCapabilitiesKHR* = object
5757 minImageCount*: uint32
5758 maxImageCount*: uint32
5759 currentExtent*: VkExtent2D
5760 minImageExtent*: VkExtent2D
5761 maxImageExtent*: VkExtent2D
5762 maxImageArrayLayers*: uint32
5763 supportedTransforms*: VkSurfaceTransformFlagsKHR
5764 currentTransform*: VkSurfaceTransformFlagBitsKHR
5765 supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR
5766 supportedUsageFlags*: VkImageUsageFlags
5767 VkSurfaceFormatKHR* = object
5768 format*: VkFormat
5769 colorSpace*: VkColorSpaceKHR
5770 VkSwapchainCreateInfoKHR* = object
5771 sType*: VkStructureType
5772 pNext*: pointer
5773 flags*: VkSwapchainCreateFlagsKHR
5774 surface*: VkSurfaceKHR
5775 minImageCount*: uint32
5776 imageFormat*: VkFormat
5777 imageColorSpace*: VkColorSpaceKHR
5778 imageExtent*: VkExtent2D
5779 imageArrayLayers*: uint32
5780 imageUsage*: VkImageUsageFlags
5781 imageSharingMode*: VkSharingMode
5782 queueFamilyIndexCount*: uint32
5783 pQueueFamilyIndices*: ptr uint32
5784 preTransform*: VkSurfaceTransformFlagBitsKHR
5785 compositeAlpha*: VkCompositeAlphaFlagBitsKHR
5786 presentMode*: VkPresentModeKHR
5787 clipped*: VkBool32
5788 oldSwapchain*: VkSwapchainKHR
5789 VkPresentInfoKHR* = object
5790 sType*: VkStructureType
5791 pNext*: pointer
5792 waitSemaphoreCount*: uint32
5793 pWaitSemaphores*: ptr VkSemaphore
5794 swapchainCount*: uint32
5795 pSwapchains*: ptr VkSwapchainKHR
5796 pImageIndices*: ptr uint32
5797 pResults*: ptr VkResult
5798 VkDebugReportCallbackCreateInfoEXT* = object
5799 sType*: VkStructureType
5800 pNext*: pointer
5801 flags*: VkDebugReportFlagsEXT
5802 pfnCallback*: PFN_vkDebugReportCallbackEXT
5803 pUserData*: pointer
5804 VkValidationFlagsEXT* = object
5805 sType*: VkStructureType
5806 pNext*: pointer
5807 disabledValidationCheckCount*: uint32
5808 pDisabledValidationChecks*: ptr VkValidationCheckEXT
5809 VkValidationFeaturesEXT* = object
5810 sType*: VkStructureType
5811 pNext*: pointer
5812 enabledValidationFeatureCount*: uint32
5813 pEnabledValidationFeatures*: ptr VkValidationFeatureEnableEXT
5814 disabledValidationFeatureCount*: uint32
5815 pDisabledValidationFeatures*: ptr VkValidationFeatureDisableEXT
5816 VkApplicationParametersEXT* = object
5817 sType*: VkStructureType
5818 pNext*: pointer
5819 vendorID*: uint32
5820 deviceID*: uint32
5821 key*: uint32
5822 value*: uint64
5823 VkPipelineRasterizationStateRasterizationOrderAMD* = object
5824 sType*: VkStructureType
5825 pNext*: pointer
5826 rasterizationOrder*: VkRasterizationOrderAMD
5827 VkDebugMarkerObjectNameInfoEXT* = object
5828 sType*: VkStructureType
5829 pNext*: pointer
5830 objectType*: VkDebugReportObjectTypeEXT
5831 theobject*: uint64
5832 pObjectName*: cstring
5833 VkDebugMarkerObjectTagInfoEXT* = object
5834 sType*: VkStructureType
5835 pNext*: pointer
5836 objectType*: VkDebugReportObjectTypeEXT
5837 theobject*: uint64
5838 tagName*: uint64
5839 tagSize*: csize_t
5840 pTag*: pointer
5841 VkDebugMarkerMarkerInfoEXT* = object
5842 sType*: VkStructureType
5843 pNext*: pointer
5844 pMarkerName*: cstring
5845 color*: array[4, float32]
5846 VkDedicatedAllocationImageCreateInfoNV* = object
5847 sType*: VkStructureType
5848 pNext*: pointer
5849 dedicatedAllocation*: VkBool32
5850 VkDedicatedAllocationBufferCreateInfoNV* = object
5851 sType*: VkStructureType
5852 pNext*: pointer
5853 dedicatedAllocation*: VkBool32
5854 VkDedicatedAllocationMemoryAllocateInfoNV* = object
5855 sType*: VkStructureType
5856 pNext*: pointer
5857 image*: VkImage
5858 buffer*: VkBuffer
5859 VkExternalImageFormatPropertiesNV* = object
5860 imageFormatProperties*: VkImageFormatProperties
5861 externalMemoryFeatures*: VkExternalMemoryFeatureFlagsNV
5862 exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlagsNV
5863 compatibleHandleTypes*: VkExternalMemoryHandleTypeFlagsNV
5864 VkExternalMemoryImageCreateInfoNV* = object
5865 sType*: VkStructureType
5866 pNext*: pointer
5867 handleTypes*: VkExternalMemoryHandleTypeFlagsNV
5868 VkExportMemoryAllocateInfoNV* = object
5869 sType*: VkStructureType
5870 pNext*: pointer
5871 handleTypes*: VkExternalMemoryHandleTypeFlagsNV
5872 VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* = object
5873 sType*: VkStructureType
5874 pNext*: pointer
5875 deviceGeneratedCommands*: VkBool32
5876 VkDevicePrivateDataCreateInfo* = object
5877 sType*: VkStructureType
5878 pNext*: pointer
5879 privateDataSlotRequestCount*: uint32
5880 VkDevicePrivateDataCreateInfoEXT* = object
5881 VkPrivateDataSlotCreateInfo* = object
5882 sType*: VkStructureType
5883 pNext*: pointer
5884 flags*: VkPrivateDataSlotCreateFlags
5885 VkPrivateDataSlotCreateInfoEXT* = object
5886 VkPhysicalDevicePrivateDataFeatures* = object
5887 sType*: VkStructureType
5888 pNext*: pointer
5889 privateData*: VkBool32
5890 VkPhysicalDevicePrivateDataFeaturesEXT* = object
5891 VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* = object
5892 sType*: VkStructureType
5893 pNext*: pointer
5894 maxGraphicsShaderGroupCount*: uint32
5895 maxIndirectSequenceCount*: uint32
5896 maxIndirectCommandsTokenCount*: uint32
5897 maxIndirectCommandsStreamCount*: uint32
5898 maxIndirectCommandsTokenOffset*: uint32
5899 maxIndirectCommandsStreamStride*: uint32
5900 minSequencesCountBufferOffsetAlignment*: uint32
5901 minSequencesIndexBufferOffsetAlignment*: uint32
5902 minIndirectCommandsBufferOffsetAlignment*: uint32
5903 VkPhysicalDeviceMultiDrawPropertiesEXT* = object
5904 sType*: VkStructureType
5905 pNext*: pointer
5906 maxMultiDrawCount*: uint32
5907 VkGraphicsShaderGroupCreateInfoNV* = object
5908 sType*: VkStructureType
5909 pNext*: pointer
5910 stageCount*: uint32
5911 pStages*: ptr VkPipelineShaderStageCreateInfo
5912 pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo
5913 pTessellationState*: ptr VkPipelineTessellationStateCreateInfo
5914 VkGraphicsPipelineShaderGroupsCreateInfoNV* = object
5915 sType*: VkStructureType
5916 pNext*: pointer
5917 groupCount*: uint32
5918 pGroups*: ptr VkGraphicsShaderGroupCreateInfoNV
5919 pipelineCount*: uint32
5920 pPipelines*: ptr VkPipeline
5921 VkBindShaderGroupIndirectCommandNV* = object
5922 groupIndex*: uint32
5923 VkBindIndexBufferIndirectCommandNV* = object
5924 bufferAddress*: VkDeviceAddress
5925 size*: uint32
5926 indexType*: VkIndexType
5927 VkBindVertexBufferIndirectCommandNV* = object
5928 bufferAddress*: VkDeviceAddress
5929 size*: uint32
5930 stride*: uint32
5931 VkSetStateFlagsIndirectCommandNV* = object
5932 data*: uint32
5933 VkIndirectCommandsStreamNV* = object
5934 buffer*: VkBuffer
5935 offset*: VkDeviceSize
5936 VkIndirectCommandsLayoutTokenNV* = object
5937 sType*: VkStructureType
5938 pNext*: pointer
5939 tokenType*: VkIndirectCommandsTokenTypeNV
5940 stream*: uint32
5941 offset*: uint32
5942 vertexBindingUnit*: uint32
5943 vertexDynamicStride*: VkBool32
5944 pushconstantPipelineLayout*: VkPipelineLayout
5945 pushconstantShaderStageFlags*: VkShaderStageFlags
5946 pushconstantOffset*: uint32
5947 pushconstantSize*: uint32
5948 indirectStateFlags*: VkIndirectStateFlagsNV
5949 indexTypeCount*: uint32
5950 pIndexTypes*: ptr VkIndexType
5951 pIndexTypeValues*: ptr uint32
5952 VkIndirectCommandsLayoutCreateInfoNV* = object
5953 sType*: VkStructureType
5954 pNext*: pointer
5955 flags*: VkIndirectCommandsLayoutUsageFlagsNV
5956 pipelineBindPoint*: VkPipelineBindPoint
5957 tokenCount*: uint32
5958 pTokens*: ptr VkIndirectCommandsLayoutTokenNV
5959 streamCount*: uint32
5960 pStreamStrides*: ptr uint32
5961 VkGeneratedCommandsInfoNV* = object
5962 sType*: VkStructureType
5963 pNext*: pointer
5964 pipelineBindPoint*: VkPipelineBindPoint
5965 pipeline*: VkPipeline
5966 indirectCommandsLayout*: VkIndirectCommandsLayoutNV
5967 streamCount*: uint32
5968 pStreams*: ptr VkIndirectCommandsStreamNV
5969 sequencesCount*: uint32
5970 preprocessBuffer*: VkBuffer
5971 preprocessOffset*: VkDeviceSize
5972 preprocessSize*: VkDeviceSize
5973 sequencesCountBuffer*: VkBuffer
5974 sequencesCountOffset*: VkDeviceSize
5975 sequencesIndexBuffer*: VkBuffer
5976 sequencesIndexOffset*: VkDeviceSize
5977 VkGeneratedCommandsMemoryRequirementsInfoNV* = object
5978 sType*: VkStructureType
5979 pNext*: pointer
5980 pipelineBindPoint*: VkPipelineBindPoint
5981 pipeline*: VkPipeline
5982 indirectCommandsLayout*: VkIndirectCommandsLayoutNV
5983 maxSequencesCount*: uint32
5984 VkPhysicalDeviceFeatures2* = object
5985 sType*: VkStructureType
5986 pNext*: pointer
5987 features*: VkPhysicalDeviceFeatures
5988 VkPhysicalDeviceFeatures2KHR* = object
5989 VkPhysicalDeviceProperties2* = object
5990 sType*: VkStructureType
5991 pNext*: pointer
5992 properties*: VkPhysicalDeviceProperties
5993 VkPhysicalDeviceProperties2KHR* = object
5994 VkFormatProperties2* = object
5995 sType*: VkStructureType
5996 pNext*: pointer
5997 formatProperties*: VkFormatProperties
5998 VkFormatProperties2KHR* = object
5999 VkImageFormatProperties2* = object
6000 sType*: VkStructureType
6001 pNext*: pointer
6002 imageFormatProperties*: VkImageFormatProperties
6003 VkImageFormatProperties2KHR* = object
6004 VkPhysicalDeviceImageFormatInfo2* = object
6005 sType*: VkStructureType
6006 pNext*: pointer
6007 format*: VkFormat
6008 thetype*: VkImageType
6009 tiling*: VkImageTiling
6010 usage*: VkImageUsageFlags
6011 flags*: VkImageCreateFlags
6012 VkPhysicalDeviceImageFormatInfo2KHR* = object
6013 VkQueueFamilyProperties2* = object
6014 sType*: VkStructureType
6015 pNext*: pointer
6016 queueFamilyProperties*: VkQueueFamilyProperties
6017 VkQueueFamilyProperties2KHR* = object
6018 VkPhysicalDeviceMemoryProperties2* = object
6019 sType*: VkStructureType
6020 pNext*: pointer
6021 memoryProperties*: VkPhysicalDeviceMemoryProperties
6022 VkPhysicalDeviceMemoryProperties2KHR* = object
6023 VkSparseImageFormatProperties2* = object
6024 sType*: VkStructureType
6025 pNext*: pointer
6026 properties*: VkSparseImageFormatProperties
6027 VkSparseImageFormatProperties2KHR* = object
6028 VkPhysicalDeviceSparseImageFormatInfo2* = object
6029 sType*: VkStructureType
6030 pNext*: pointer
6031 format*: VkFormat
6032 thetype*: VkImageType
6033 samples*: VkSampleCountFlagBits
6034 usage*: VkImageUsageFlags
6035 tiling*: VkImageTiling
6036 VkPhysicalDeviceSparseImageFormatInfo2KHR* = object
6037 VkPhysicalDevicePushDescriptorPropertiesKHR* = object
6038 sType*: VkStructureType
6039 pNext*: pointer
6040 maxPushDescriptors*: uint32
6041 VkConformanceVersion* = object
6042 major*: uint8
6043 minor*: uint8
6044 subminor*: uint8
6045 patch*: uint8
6046 VkConformanceVersionKHR* = object
6047 VkPhysicalDeviceDriverProperties* = object
6048 sType*: VkStructureType
6049 pNext*: pointer
6050 driverID*: VkDriverId
6051 driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char]
6052 driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char]
6053 conformanceVersion*: VkConformanceVersion
6054 VkPhysicalDeviceDriverPropertiesKHR* = object
6055 VkPresentRegionsKHR* = object
6056 sType*: VkStructureType
6057 pNext*: pointer
6058 swapchainCount*: uint32
6059 pRegions*: ptr VkPresentRegionKHR
6060 VkPresentRegionKHR* = object
6061 rectangleCount*: uint32
6062 pRectangles*: ptr VkRectLayerKHR
6063 VkRectLayerKHR* = object
6064 offset*: VkOffset2D
6065 extent*: VkExtent2D
6066 layer*: uint32
6067 VkPhysicalDeviceVariablePointersFeatures* = object
6068 sType*: VkStructureType
6069 pNext*: pointer
6070 variablePointersStorageBuffer*: VkBool32
6071 variablePointers*: VkBool32
6072 VkPhysicalDeviceVariablePointersFeaturesKHR* = object
6073 VkPhysicalDeviceVariablePointerFeaturesKHR* = object
6074 VkPhysicalDeviceVariablePointerFeatures* = object
6075 VkExternalMemoryProperties* = object
6076 externalMemoryFeatures*: VkExternalMemoryFeatureFlags
6077 exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlags
6078 compatibleHandleTypes*: VkExternalMemoryHandleTypeFlags
6079 VkExternalMemoryPropertiesKHR* = object
6080 VkPhysicalDeviceExternalImageFormatInfo* = object
6081 sType*: VkStructureType
6082 pNext*: pointer
6083 handleType*: VkExternalMemoryHandleTypeFlagBits
6084 VkPhysicalDeviceExternalImageFormatInfoKHR* = object
6085 VkExternalImageFormatProperties* = object
6086 sType*: VkStructureType
6087 pNext*: pointer
6088 externalMemoryProperties*: VkExternalMemoryProperties
6089 VkExternalImageFormatPropertiesKHR* = object
6090 VkPhysicalDeviceExternalBufferInfo* = object
6091 sType*: VkStructureType
6092 pNext*: pointer
6093 flags*: VkBufferCreateFlags
6094 usage*: VkBufferUsageFlags
6095 handleType*: VkExternalMemoryHandleTypeFlagBits
6096 VkPhysicalDeviceExternalBufferInfoKHR* = object
6097 VkExternalBufferProperties* = object
6098 sType*: VkStructureType
6099 pNext*: pointer
6100 externalMemoryProperties*: VkExternalMemoryProperties
6101 VkExternalBufferPropertiesKHR* = object
6102 VkPhysicalDeviceIDProperties* = object
6103 sType*: VkStructureType
6104 pNext*: pointer
6105 deviceUUID*: array[VK_UUID_SIZE, uint8]
6106 driverUUID*: array[VK_UUID_SIZE, uint8]
6107 deviceLUID*: array[VK_LUID_SIZE, uint8]
6108 deviceNodeMask*: uint32
6109 deviceLUIDValid*: VkBool32
6110 VkPhysicalDeviceIDPropertiesKHR* = object
6111 VkExternalMemoryImageCreateInfo* = object
6112 sType*: VkStructureType
6113 pNext*: pointer
6114 handleTypes*: VkExternalMemoryHandleTypeFlags
6115 VkExternalMemoryImageCreateInfoKHR* = object
6116 VkExternalMemoryBufferCreateInfo* = object
6117 sType*: VkStructureType
6118 pNext*: pointer
6119 handleTypes*: VkExternalMemoryHandleTypeFlags
6120 VkExternalMemoryBufferCreateInfoKHR* = object
6121 VkExportMemoryAllocateInfo* = object
6122 sType*: VkStructureType
6123 pNext*: pointer
6124 handleTypes*: VkExternalMemoryHandleTypeFlags
6125 VkExportMemoryAllocateInfoKHR* = object
6126 VkImportMemoryFdInfoKHR* = object
6127 sType*: VkStructureType
6128 pNext*: pointer
6129 handleType*: VkExternalMemoryHandleTypeFlagBits
6130 fd*: cint
6131 VkMemoryFdPropertiesKHR* = object
6132 sType*: VkStructureType
6133 pNext*: pointer
6134 memoryTypeBits*: uint32
6135 VkMemoryGetFdInfoKHR* = object
6136 sType*: VkStructureType
6137 pNext*: pointer
6138 memory*: VkDeviceMemory
6139 handleType*: VkExternalMemoryHandleTypeFlagBits
6140 VkPhysicalDeviceExternalSemaphoreInfo* = object
6141 sType*: VkStructureType
6142 pNext*: pointer
6143 handleType*: VkExternalSemaphoreHandleTypeFlagBits
6144 VkPhysicalDeviceExternalSemaphoreInfoKHR* = object
6145 VkExternalSemaphoreProperties* = object
6146 sType*: VkStructureType
6147 pNext*: pointer
6148 exportFromImportedHandleTypes*: VkExternalSemaphoreHandleTypeFlags
6149 compatibleHandleTypes*: VkExternalSemaphoreHandleTypeFlags
6150 externalSemaphoreFeatures*: VkExternalSemaphoreFeatureFlags
6151 VkExternalSemaphorePropertiesKHR* = object
6152 VkExportSemaphoreCreateInfo* = object
6153 sType*: VkStructureType
6154 pNext*: pointer
6155 handleTypes*: VkExternalSemaphoreHandleTypeFlags
6156 VkExportSemaphoreCreateInfoKHR* = object
6157 VkImportSemaphoreFdInfoKHR* = object
6158 sType*: VkStructureType
6159 pNext*: pointer
6160 semaphore*: VkSemaphore
6161 flags*: VkSemaphoreImportFlags
6162 handleType*: VkExternalSemaphoreHandleTypeFlagBits
6163 fd*: cint
6164 VkSemaphoreGetFdInfoKHR* = object
6165 sType*: VkStructureType
6166 pNext*: pointer
6167 semaphore*: VkSemaphore
6168 handleType*: VkExternalSemaphoreHandleTypeFlagBits
6169 VkPhysicalDeviceExternalFenceInfo* = object
6170 sType*: VkStructureType
6171 pNext*: pointer
6172 handleType*: VkExternalFenceHandleTypeFlagBits
6173 VkPhysicalDeviceExternalFenceInfoKHR* = object
6174 VkExternalFenceProperties* = object
6175 sType*: VkStructureType
6176 pNext*: pointer
6177 exportFromImportedHandleTypes*: VkExternalFenceHandleTypeFlags
6178 compatibleHandleTypes*: VkExternalFenceHandleTypeFlags
6179 externalFenceFeatures*: VkExternalFenceFeatureFlags
6180 VkExternalFencePropertiesKHR* = object
6181 VkExportFenceCreateInfo* = object
6182 sType*: VkStructureType
6183 pNext*: pointer
6184 handleTypes*: VkExternalFenceHandleTypeFlags
6185 VkExportFenceCreateInfoKHR* = object
6186 VkImportFenceFdInfoKHR* = object
6187 sType*: VkStructureType
6188 pNext*: pointer
6189 fence*: VkFence
6190 flags*: VkFenceImportFlags
6191 handleType*: VkExternalFenceHandleTypeFlagBits
6192 fd*: cint
6193 VkFenceGetFdInfoKHR* = object
6194 sType*: VkStructureType
6195 pNext*: pointer
6196 fence*: VkFence
6197 handleType*: VkExternalFenceHandleTypeFlagBits
6198 VkPhysicalDeviceMultiviewFeatures* = object
6199 sType*: VkStructureType
6200 pNext*: pointer
6201 multiview*: VkBool32
6202 multiviewGeometryShader*: VkBool32
6203 multiviewTessellationShader*: VkBool32
6204 VkPhysicalDeviceMultiviewFeaturesKHR* = object
6205 VkPhysicalDeviceMultiviewProperties* = object
6206 sType*: VkStructureType
6207 pNext*: pointer
6208 maxMultiviewViewCount*: uint32
6209 maxMultiviewInstanceIndex*: uint32
6210 VkPhysicalDeviceMultiviewPropertiesKHR* = object
6211 VkRenderPassMultiviewCreateInfo* = object
6212 sType*: VkStructureType
6213 pNext*: pointer
6214 subpassCount*: uint32
6215 pViewMasks*: ptr uint32
6216 dependencyCount*: uint32
6217 pViewOffsets*: ptr int32
6218 correlationMaskCount*: uint32
6219 pCorrelationMasks*: ptr uint32
6220 VkRenderPassMultiviewCreateInfoKHR* = object
6221 VkSurfaceCapabilities2EXT* = object
6222 sType*: VkStructureType
6223 pNext*: pointer
6224 minImageCount*: uint32
6225 maxImageCount*: uint32
6226 currentExtent*: VkExtent2D
6227 minImageExtent*: VkExtent2D
6228 maxImageExtent*: VkExtent2D
6229 maxImageArrayLayers*: uint32
6230 supportedTransforms*: VkSurfaceTransformFlagsKHR
6231 currentTransform*: VkSurfaceTransformFlagBitsKHR
6232 supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR
6233 supportedUsageFlags*: VkImageUsageFlags
6234 supportedSurfaceCounters*: VkSurfaceCounterFlagsEXT
6235 VkDisplayPowerInfoEXT* = object
6236 sType*: VkStructureType
6237 pNext*: pointer
6238 powerState*: VkDisplayPowerStateEXT
6239 VkDeviceEventInfoEXT* = object
6240 sType*: VkStructureType
6241 pNext*: pointer
6242 deviceEvent*: VkDeviceEventTypeEXT
6243 VkDisplayEventInfoEXT* = object
6244 sType*: VkStructureType
6245 pNext*: pointer
6246 displayEvent*: VkDisplayEventTypeEXT
6247 VkSwapchainCounterCreateInfoEXT* = object
6248 sType*: VkStructureType
6249 pNext*: pointer
6250 surfaceCounters*: VkSurfaceCounterFlagsEXT
6251 VkPhysicalDeviceGroupProperties* = object
6252 sType*: VkStructureType
6253 pNext*: pointer
6254 physicalDeviceCount*: uint32
6255 physicalDevices*: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice]
6256 subsetAllocation*: VkBool32
6257 VkPhysicalDeviceGroupPropertiesKHR* = object
6258 VkMemoryAllocateFlagsInfo* = object
6259 sType*: VkStructureType
6260 pNext*: pointer
6261 flags*: VkMemoryAllocateFlags
6262 deviceMask*: uint32
6263 VkMemoryAllocateFlagsInfoKHR* = object
6264 VkBindBufferMemoryInfo* = object
6265 sType*: VkStructureType
6266 pNext*: pointer
6267 buffer*: VkBuffer
6268 memory*: VkDeviceMemory
6269 memoryOffset*: VkDeviceSize
6270 VkBindBufferMemoryInfoKHR* = object
6271 VkBindBufferMemoryDeviceGroupInfo* = object
6272 sType*: VkStructureType
6273 pNext*: pointer
6274 deviceIndexCount*: uint32
6275 pDeviceIndices*: ptr uint32
6276 VkBindBufferMemoryDeviceGroupInfoKHR* = object
6277 VkBindImageMemoryInfo* = object
6278 sType*: VkStructureType
6279 pNext*: pointer
6280 image*: VkImage
6281 memory*: VkDeviceMemory
6282 memoryOffset*: VkDeviceSize
6283 VkBindImageMemoryInfoKHR* = object
6284 VkBindImageMemoryDeviceGroupInfo* = object
6285 sType*: VkStructureType
6286 pNext*: pointer
6287 deviceIndexCount*: uint32
6288 pDeviceIndices*: ptr uint32
6289 splitInstanceBindRegionCount*: uint32
6290 pSplitInstanceBindRegions*: ptr VkRect2D
6291 VkBindImageMemoryDeviceGroupInfoKHR* = object
6292 VkDeviceGroupRenderPassBeginInfo* = object
6293 sType*: VkStructureType
6294 pNext*: pointer
6295 deviceMask*: uint32
6296 deviceRenderAreaCount*: uint32
6297 pDeviceRenderAreas*: ptr VkRect2D
6298 VkDeviceGroupRenderPassBeginInfoKHR* = object
6299 VkDeviceGroupCommandBufferBeginInfo* = object
6300 sType*: VkStructureType
6301 pNext*: pointer
6302 deviceMask*: uint32
6303 VkDeviceGroupCommandBufferBeginInfoKHR* = object
6304 VkDeviceGroupSubmitInfo* = object
6305 sType*: VkStructureType
6306 pNext*: pointer
6307 waitSemaphoreCount*: uint32
6308 pWaitSemaphoreDeviceIndices*: ptr uint32
6309 commandBufferCount*: uint32
6310 pCommandBufferDeviceMasks*: ptr uint32
6311 signalSemaphoreCount*: uint32
6312 pSignalSemaphoreDeviceIndices*: ptr uint32
6313 VkDeviceGroupSubmitInfoKHR* = object
6314 VkDeviceGroupBindSparseInfo* = object
6315 sType*: VkStructureType
6316 pNext*: pointer
6317 resourceDeviceIndex*: uint32
6318 memoryDeviceIndex*: uint32
6319 VkDeviceGroupBindSparseInfoKHR* = object
6320 VkDeviceGroupPresentCapabilitiesKHR* = object
6321 sType*: VkStructureType
6322 pNext*: pointer
6323 presentMask*: array[VK_MAX_DEVICE_GROUP_SIZE, uint32]
6324 modes*: VkDeviceGroupPresentModeFlagsKHR
6325 VkImageSwapchainCreateInfoKHR* = object
6326 sType*: VkStructureType
6327 pNext*: pointer
6328 swapchain*: VkSwapchainKHR
6329 VkBindImageMemorySwapchainInfoKHR* = object
6330 sType*: VkStructureType
6331 pNext*: pointer
6332 swapchain*: VkSwapchainKHR
6333 imageIndex*: uint32
6334 VkAcquireNextImageInfoKHR* = object
6335 sType*: VkStructureType
6336 pNext*: pointer
6337 swapchain*: VkSwapchainKHR
6338 timeout*: uint64
6339 semaphore*: VkSemaphore
6340 fence*: VkFence
6341 deviceMask*: uint32
6342 VkDeviceGroupPresentInfoKHR* = object
6343 sType*: VkStructureType
6344 pNext*: pointer
6345 swapchainCount*: uint32
6346 pDeviceMasks*: ptr uint32
6347 mode*: VkDeviceGroupPresentModeFlagBitsKHR
6348 VkDeviceGroupDeviceCreateInfo* = object
6349 sType*: VkStructureType
6350 pNext*: pointer
6351 physicalDeviceCount*: uint32
6352 pPhysicalDevices*: ptr VkPhysicalDevice
6353 VkDeviceGroupDeviceCreateInfoKHR* = object
6354 VkDeviceGroupSwapchainCreateInfoKHR* = object
6355 sType*: VkStructureType
6356 pNext*: pointer
6357 modes*: VkDeviceGroupPresentModeFlagsKHR
6358 VkDescriptorUpdateTemplateEntry* = object
6359 dstBinding*: uint32
6360 dstArrayElement*: uint32
6361 descriptorCount*: uint32
6362 descriptorType*: VkDescriptorType
6363 offset*: csize_t
6364 stride*: csize_t
6365 VkDescriptorUpdateTemplateEntryKHR* = object
6366 VkDescriptorUpdateTemplateCreateInfo* = object
6367 sType*: VkStructureType
6368 pNext*: pointer
6369 flags*: VkDescriptorUpdateTemplateCreateFlags
6370 descriptorUpdateEntryCount*: uint32
6371 pDescriptorUpdateEntries*: ptr VkDescriptorUpdateTemplateEntry
6372 templateType*: VkDescriptorUpdateTemplateType
6373 descriptorSetLayout*: VkDescriptorSetLayout
6374 pipelineBindPoint*: VkPipelineBindPoint
6375 pipelineLayout*: VkPipelineLayout
6376 set*: uint32
6377 VkDescriptorUpdateTemplateCreateInfoKHR* = object
6378 VkXYColorEXT* = object
6379 x*: float32
6380 y*: float32
6381 VkPhysicalDevicePresentIdFeaturesKHR* = object
6382 sType*: VkStructureType
6383 pNext*: pointer
6384 presentId*: VkBool32
6385 VkPresentIdKHR* = object
6386 sType*: VkStructureType
6387 pNext*: pointer
6388 swapchainCount*: uint32
6389 pPresentIds*: ptr uint64
6390 VkPhysicalDevicePresentWaitFeaturesKHR* = object
6391 sType*: VkStructureType
6392 pNext*: pointer
6393 presentWait*: VkBool32
6394 VkHdrMetadataEXT* = object
6395 sType*: VkStructureType
6396 pNext*: pointer
6397 displayPrimaryRed*: VkXYColorEXT
6398 displayPrimaryGreen*: VkXYColorEXT
6399 displayPrimaryBlue*: VkXYColorEXT
6400 whitePoint*: VkXYColorEXT
6401 maxLuminance*: float32
6402 minLuminance*: float32
6403 maxContentLightLevel*: float32
6404 maxFrameAverageLightLevel*: float32
6405 VkDisplayNativeHdrSurfaceCapabilitiesAMD* = object
6406 sType*: VkStructureType
6407 pNext*: pointer
6408 localDimmingSupport*: VkBool32
6409 VkSwapchainDisplayNativeHdrCreateInfoAMD* = object
6410 sType*: VkStructureType
6411 pNext*: pointer
6412 localDimmingEnable*: VkBool32
6413 VkRefreshCycleDurationGOOGLE* = object
6414 refreshDuration*: uint64
6415 VkPastPresentationTimingGOOGLE* = object
6416 presentID*: uint32
6417 desiredPresentTime*: uint64
6418 actualPresentTime*: uint64
6419 earliestPresentTime*: uint64
6420 presentMargin*: uint64
6421 VkPresentTimesInfoGOOGLE* = object
6422 sType*: VkStructureType
6423 pNext*: pointer
6424 swapchainCount*: uint32
6425 pTimes*: ptr VkPresentTimeGOOGLE
6426 VkPresentTimeGOOGLE* = object
6427 presentID*: uint32
6428 desiredPresentTime*: uint64
6429 VkViewportWScalingNV* = object
6430 xcoeff*: float32
6431 ycoeff*: float32
6432 VkPipelineViewportWScalingStateCreateInfoNV* = object
6433 sType*: VkStructureType
6434 pNext*: pointer
6435 viewportWScalingEnable*: VkBool32
6436 viewportCount*: uint32
6437 pViewportWScalings*: ptr VkViewportWScalingNV
6438 VkViewportSwizzleNV* = object
6439 x*: VkViewportCoordinateSwizzleNV
6440 y*: VkViewportCoordinateSwizzleNV
6441 z*: VkViewportCoordinateSwizzleNV
6442 w*: VkViewportCoordinateSwizzleNV
6443 VkPipelineViewportSwizzleStateCreateInfoNV* = object
6444 sType*: VkStructureType
6445 pNext*: pointer
6446 flags*: VkPipelineViewportSwizzleStateCreateFlagsNV
6447 viewportCount*: uint32
6448 pViewportSwizzles*: ptr VkViewportSwizzleNV
6449 VkPhysicalDeviceDiscardRectanglePropertiesEXT* = object
6450 sType*: VkStructureType
6451 pNext*: pointer
6452 maxDiscardRectangles*: uint32
6453 VkPipelineDiscardRectangleStateCreateInfoEXT* = object
6454 sType*: VkStructureType
6455 pNext*: pointer
6456 flags*: VkPipelineDiscardRectangleStateCreateFlagsEXT
6457 discardRectangleMode*: VkDiscardRectangleModeEXT
6458 discardRectangleCount*: uint32
6459 pDiscardRectangles*: ptr VkRect2D
6460 VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* = object
6461 sType*: VkStructureType
6462 pNext*: pointer
6463 perViewPositionAllComponents*: VkBool32
6464 VkInputAttachmentAspectReference* = object
6465 subpass*: uint32
6466 inputAttachmentIndex*: uint32
6467 aspectMask*: VkImageAspectFlags
6468 VkInputAttachmentAspectReferenceKHR* = object
6469 VkRenderPassInputAttachmentAspectCreateInfo* = object
6470 sType*: VkStructureType
6471 pNext*: pointer
6472 aspectReferenceCount*: uint32
6473 pAspectReferences*: ptr VkInputAttachmentAspectReference
6474 VkRenderPassInputAttachmentAspectCreateInfoKHR* = object
6475 VkPhysicalDeviceSurfaceInfo2KHR* = object
6476 sType*: VkStructureType
6477 pNext*: pointer
6478 surface*: VkSurfaceKHR
6479 VkSurfaceCapabilities2KHR* = object
6480 sType*: VkStructureType
6481 pNext*: pointer
6482 surfaceCapabilities*: VkSurfaceCapabilitiesKHR
6483 VkSurfaceFormat2KHR* = object
6484 sType*: VkStructureType
6485 pNext*: pointer
6486 surfaceFormat*: VkSurfaceFormatKHR
6487 VkDisplayProperties2KHR* = object
6488 sType*: VkStructureType
6489 pNext*: pointer
6490 displayProperties*: VkDisplayPropertiesKHR
6491 VkDisplayPlaneProperties2KHR* = object
6492 sType*: VkStructureType
6493 pNext*: pointer
6494 displayPlaneProperties*: VkDisplayPlanePropertiesKHR
6495 VkDisplayModeProperties2KHR* = object
6496 sType*: VkStructureType
6497 pNext*: pointer
6498 displayModeProperties*: VkDisplayModePropertiesKHR
6499 VkDisplayPlaneInfo2KHR* = object
6500 sType*: VkStructureType
6501 pNext*: pointer
6502 mode*: VkDisplayModeKHR
6503 planeIndex*: uint32
6504 VkDisplayPlaneCapabilities2KHR* = object
6505 sType*: VkStructureType
6506 pNext*: pointer
6507 capabilities*: VkDisplayPlaneCapabilitiesKHR
6508 VkSharedPresentSurfaceCapabilitiesKHR* = object
6509 sType*: VkStructureType
6510 pNext*: pointer
6511 sharedPresentSupportedUsageFlags*: VkImageUsageFlags
6512 VkPhysicalDevice16BitStorageFeatures* = object
6513 sType*: VkStructureType
6514 pNext*: pointer
6515 storageBuffer16BitAccess*: VkBool32
6516 uniformAndStorageBuffer16BitAccess*: VkBool32
6517 storagePushConstant16*: VkBool32
6518 storageInputOutput16*: VkBool32
6519 VkPhysicalDevice16BitStorageFeaturesKHR* = object
6520 VkPhysicalDeviceSubgroupProperties* = object
6521 sType*: VkStructureType
6522 pNext*: pointer
6523 subgroupSize*: uint32
6524 supportedStages*: VkShaderStageFlags
6525 supportedOperations*: VkSubgroupFeatureFlags
6526 quadOperationsInAllStages*: VkBool32
6527 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* = object
6528 sType*: VkStructureType
6529 pNext*: pointer
6530 shaderSubgroupExtendedTypes*: VkBool32
6531 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR* = object
6532 VkBufferMemoryRequirementsInfo2* = object
6533 sType*: VkStructureType
6534 pNext*: pointer
6535 buffer*: VkBuffer
6536 VkBufferMemoryRequirementsInfo2KHR* = object
6537 VkDeviceBufferMemoryRequirements* = object
6538 sType*: VkStructureType
6539 pNext*: pointer
6540 pCreateInfo*: ptr VkBufferCreateInfo
6541 VkDeviceBufferMemoryRequirementsKHR* = object
6542 VkImageMemoryRequirementsInfo2* = object
6543 sType*: VkStructureType
6544 pNext*: pointer
6545 image*: VkImage
6546 VkImageMemoryRequirementsInfo2KHR* = object
6547 VkImageSparseMemoryRequirementsInfo2* = object
6548 sType*: VkStructureType
6549 pNext*: pointer
6550 image*: VkImage
6551 VkImageSparseMemoryRequirementsInfo2KHR* = object
6552 VkDeviceImageMemoryRequirements* = object
6553 sType*: VkStructureType
6554 pNext*: pointer
6555 pCreateInfo*: ptr VkImageCreateInfo
6556 planeAspect*: VkImageAspectFlagBits
6557 VkDeviceImageMemoryRequirementsKHR* = object
6558 VkMemoryRequirements2* = object
6559 sType*: VkStructureType
6560 pNext*: pointer
6561 memoryRequirements*: VkMemoryRequirements
6562 VkMemoryRequirements2KHR* = object
6563 VkSparseImageMemoryRequirements2* = object
6564 sType*: VkStructureType
6565 pNext*: pointer
6566 memoryRequirements*: VkSparseImageMemoryRequirements
6567 VkSparseImageMemoryRequirements2KHR* = object
6568 VkPhysicalDevicePointClippingProperties* = object
6569 sType*: VkStructureType
6570 pNext*: pointer
6571 pointClippingBehavior*: VkPointClippingBehavior
6572 VkPhysicalDevicePointClippingPropertiesKHR* = object
6573 VkMemoryDedicatedRequirements* = object
6574 sType*: VkStructureType
6575 pNext*: pointer
6576 prefersDedicatedAllocation*: VkBool32
6577 requiresDedicatedAllocation*: VkBool32
6578 VkMemoryDedicatedRequirementsKHR* = object
6579 VkMemoryDedicatedAllocateInfo* = object
6580 sType*: VkStructureType
6581 pNext*: pointer
6582 image*: VkImage
6583 buffer*: VkBuffer
6584 VkMemoryDedicatedAllocateInfoKHR* = object
6585 VkImageViewUsageCreateInfo* = object
6586 sType*: VkStructureType
6587 pNext*: pointer
6588 usage*: VkImageUsageFlags
6589 VkImageViewSlicedCreateInfoEXT* = object
6590 sType*: VkStructureType
6591 pNext*: pointer
6592 sliceOffset*: uint32
6593 sliceCount*: uint32
6594 VkImageViewUsageCreateInfoKHR* = object
6595 VkPipelineTessellationDomainOriginStateCreateInfo* = object
6596 sType*: VkStructureType
6597 pNext*: pointer
6598 domainOrigin*: VkTessellationDomainOrigin
6599 VkPipelineTessellationDomainOriginStateCreateInfoKHR* = object
6600 VkSamplerYcbcrConversionInfo* = object
6601 sType*: VkStructureType
6602 pNext*: pointer
6603 conversion*: VkSamplerYcbcrConversion
6604 VkSamplerYcbcrConversionInfoKHR* = object
6605 VkSamplerYcbcrConversionCreateInfo* = object
6606 sType*: VkStructureType
6607 pNext*: pointer
6608 format*: VkFormat
6609 ycbcrModel*: VkSamplerYcbcrModelConversion
6610 ycbcrRange*: VkSamplerYcbcrRange
6611 components*: VkComponentMapping
6612 xChromaOffset*: VkChromaLocation
6613 yChromaOffset*: VkChromaLocation
6614 chromaFilter*: VkFilter
6615 forceExplicitReconstruction*: VkBool32
6616 VkSamplerYcbcrConversionCreateInfoKHR* = object
6617 VkBindImagePlaneMemoryInfo* = object
6618 sType*: VkStructureType
6619 pNext*: pointer
6620 planeAspect*: VkImageAspectFlagBits
6621 VkBindImagePlaneMemoryInfoKHR* = object
6622 VkImagePlaneMemoryRequirementsInfo* = object
6623 sType*: VkStructureType
6624 pNext*: pointer
6625 planeAspect*: VkImageAspectFlagBits
6626 VkImagePlaneMemoryRequirementsInfoKHR* = object
6627 VkPhysicalDeviceSamplerYcbcrConversionFeatures* = object
6628 sType*: VkStructureType
6629 pNext*: pointer
6630 samplerYcbcrConversion*: VkBool32
6631 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* = object
6632 VkSamplerYcbcrConversionImageFormatProperties* = object
6633 sType*: VkStructureType
6634 pNext*: pointer
6635 combinedImageSamplerDescriptorCount*: uint32
6636 VkSamplerYcbcrConversionImageFormatPropertiesKHR* = object
6637 VkTextureLODGatherFormatPropertiesAMD* = object
6638 sType*: VkStructureType
6639 pNext*: pointer
6640 supportsTextureGatherLODBiasAMD*: VkBool32
6641 VkConditionalRenderingBeginInfoEXT* = object
6642 sType*: VkStructureType
6643 pNext*: pointer
6644 buffer*: VkBuffer
6645 offset*: VkDeviceSize
6646 flags*: VkConditionalRenderingFlagsEXT
6647 VkProtectedSubmitInfo* = object
6648 sType*: VkStructureType
6649 pNext*: pointer
6650 protectedSubmit*: VkBool32
6651 VkPhysicalDeviceProtectedMemoryFeatures* = object
6652 sType*: VkStructureType
6653 pNext*: pointer
6654 protectedMemory*: VkBool32
6655 VkPhysicalDeviceProtectedMemoryProperties* = object
6656 sType*: VkStructureType
6657 pNext*: pointer
6658 protectedNoFault*: VkBool32
6659 VkDeviceQueueInfo2* = object
6660 sType*: VkStructureType
6661 pNext*: pointer
6662 flags*: VkDeviceQueueCreateFlags
6663 queueFamilyIndex*: uint32
6664 queueIndex*: uint32
6665 VkPipelineCoverageToColorStateCreateInfoNV* = object
6666 sType*: VkStructureType
6667 pNext*: pointer
6668 flags*: VkPipelineCoverageToColorStateCreateFlagsNV
6669 coverageToColorEnable*: VkBool32
6670 coverageToColorLocation*: uint32
6671 VkPhysicalDeviceSamplerFilterMinmaxProperties* = object
6672 sType*: VkStructureType
6673 pNext*: pointer
6674 filterMinmaxSingleComponentFormats*: VkBool32
6675 filterMinmaxImageComponentMapping*: VkBool32
6676 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* = object
6677 VkSampleLocationEXT* = object
6678 x*: float32
6679 y*: float32
6680 VkSampleLocationsInfoEXT* = object
6681 sType*: VkStructureType
6682 pNext*: pointer
6683 sampleLocationsPerPixel*: VkSampleCountFlagBits
6684 sampleLocationGridSize*: VkExtent2D
6685 sampleLocationsCount*: uint32
6686 pSampleLocations*: ptr VkSampleLocationEXT
6687 VkAttachmentSampleLocationsEXT* = object
6688 attachmentIndex*: uint32
6689 sampleLocationsInfo*: VkSampleLocationsInfoEXT
6690 VkSubpassSampleLocationsEXT* = object
6691 subpassIndex*: uint32
6692 sampleLocationsInfo*: VkSampleLocationsInfoEXT
6693 VkRenderPassSampleLocationsBeginInfoEXT* = object
6694 sType*: VkStructureType
6695 pNext*: pointer
6696 attachmentInitialSampleLocationsCount*: uint32
6697 pAttachmentInitialSampleLocations*: ptr VkAttachmentSampleLocationsEXT
6698 postSubpassSampleLocationsCount*: uint32
6699 pPostSubpassSampleLocations*: ptr VkSubpassSampleLocationsEXT
6700 VkPipelineSampleLocationsStateCreateInfoEXT* = object
6701 sType*: VkStructureType
6702 pNext*: pointer
6703 sampleLocationsEnable*: VkBool32
6704 sampleLocationsInfo*: VkSampleLocationsInfoEXT
6705 VkPhysicalDeviceSampleLocationsPropertiesEXT* = object
6706 sType*: VkStructureType
6707 pNext*: pointer
6708 sampleLocationSampleCounts*: VkSampleCountFlags
6709 maxSampleLocationGridSize*: VkExtent2D
6710 sampleLocationCoordinateRange*: array[2, float32]
6711 sampleLocationSubPixelBits*: uint32
6712 variableSampleLocations*: VkBool32
6713 VkMultisamplePropertiesEXT* = object
6714 sType*: VkStructureType
6715 pNext*: pointer
6716 maxSampleLocationGridSize*: VkExtent2D
6717 VkSamplerReductionModeCreateInfo* = object
6718 sType*: VkStructureType
6719 pNext*: pointer
6720 reductionMode*: VkSamplerReductionMode
6721 VkSamplerReductionModeCreateInfoEXT* = object
6722 VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* = object
6723 sType*: VkStructureType
6724 pNext*: pointer
6725 advancedBlendCoherentOperations*: VkBool32
6726 VkPhysicalDeviceMultiDrawFeaturesEXT* = object
6727 sType*: VkStructureType
6728 pNext*: pointer
6729 multiDraw*: VkBool32
6730 VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* = object
6731 sType*: VkStructureType
6732 pNext*: pointer
6733 advancedBlendMaxColorAttachments*: uint32
6734 advancedBlendIndependentBlend*: VkBool32
6735 advancedBlendNonPremultipliedSrcColor*: VkBool32
6736 advancedBlendNonPremultipliedDstColor*: VkBool32
6737 advancedBlendCorrelatedOverlap*: VkBool32
6738 advancedBlendAllOperations*: VkBool32
6739 VkPipelineColorBlendAdvancedStateCreateInfoEXT* = object
6740 sType*: VkStructureType
6741 pNext*: pointer
6742 srcPremultiplied*: VkBool32
6743 dstPremultiplied*: VkBool32
6744 blendOverlap*: VkBlendOverlapEXT
6745 VkPhysicalDeviceInlineUniformBlockFeatures* = object
6746 sType*: VkStructureType
6747 pNext*: pointer
6748 inlineUniformBlock*: VkBool32
6749 descriptorBindingInlineUniformBlockUpdateAfterBind*: VkBool32
6750 VkPhysicalDeviceInlineUniformBlockFeaturesEXT* = object
6751 VkPhysicalDeviceInlineUniformBlockProperties* = object
6752 sType*: VkStructureType
6753 pNext*: pointer
6754 maxInlineUniformBlockSize*: uint32
6755 maxPerStageDescriptorInlineUniformBlocks*: uint32
6756 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks*: uint32
6757 maxDescriptorSetInlineUniformBlocks*: uint32
6758 maxDescriptorSetUpdateAfterBindInlineUniformBlocks*: uint32
6759 VkPhysicalDeviceInlineUniformBlockPropertiesEXT* = object
6760 VkWriteDescriptorSetInlineUniformBlock* = object
6761 sType*: VkStructureType
6762 pNext*: pointer
6763 dataSize*: uint32
6764 pData*: pointer
6765 VkWriteDescriptorSetInlineUniformBlockEXT* = object
6766 VkDescriptorPoolInlineUniformBlockCreateInfo* = object
6767 sType*: VkStructureType
6768 pNext*: pointer
6769 maxInlineUniformBlockBindings*: uint32
6770 VkDescriptorPoolInlineUniformBlockCreateInfoEXT* = object
6771 VkPipelineCoverageModulationStateCreateInfoNV* = object
6772 sType*: VkStructureType
6773 pNext*: pointer
6774 flags*: VkPipelineCoverageModulationStateCreateFlagsNV
6775 coverageModulationMode*: VkCoverageModulationModeNV
6776 coverageModulationTableEnable*: VkBool32
6777 coverageModulationTableCount*: uint32
6778 pCoverageModulationTable*: ptr float32
6779 VkImageFormatListCreateInfo* = object
6780 sType*: VkStructureType
6781 pNext*: pointer
6782 viewFormatCount*: uint32
6783 pViewFormats*: ptr VkFormat
6784 VkImageFormatListCreateInfoKHR* = object
6785 VkValidationCacheCreateInfoEXT* = object
6786 sType*: VkStructureType
6787 pNext*: pointer
6788 flags*: VkValidationCacheCreateFlagsEXT
6789 initialDataSize*: csize_t
6790 pInitialData*: pointer
6791 VkShaderModuleValidationCacheCreateInfoEXT* = object
6792 sType*: VkStructureType
6793 pNext*: pointer
6794 validationCache*: VkValidationCacheEXT
6795 VkPhysicalDeviceMaintenance3Properties* = object
6796 sType*: VkStructureType
6797 pNext*: pointer
6798 maxPerSetDescriptors*: uint32
6799 maxMemoryAllocationSize*: VkDeviceSize
6800 VkPhysicalDeviceMaintenance3PropertiesKHR* = object
6801 VkPhysicalDeviceMaintenance4Features* = object
6802 sType*: VkStructureType
6803 pNext*: pointer
6804 maintenance4*: VkBool32
6805 VkPhysicalDeviceMaintenance4FeaturesKHR* = object
6806 VkPhysicalDeviceMaintenance4Properties* = object
6807 sType*: VkStructureType
6808 pNext*: pointer
6809 maxBufferSize*: VkDeviceSize
6810 VkPhysicalDeviceMaintenance4PropertiesKHR* = object
6811 VkDescriptorSetLayoutSupport* = object
6812 sType*: VkStructureType
6813 pNext*: pointer
6814 supported*: VkBool32
6815 VkDescriptorSetLayoutSupportKHR* = object
6816 VkPhysicalDeviceShaderDrawParametersFeatures* = object
6817 sType*: VkStructureType
6818 pNext*: pointer
6819 shaderDrawParameters*: VkBool32
6820 VkPhysicalDeviceShaderDrawParameterFeatures* = object
6821 VkPhysicalDeviceShaderFloat16Int8Features* = object
6822 sType*: VkStructureType
6823 pNext*: pointer
6824 shaderFloat16*: VkBool32
6825 shaderInt8*: VkBool32
6826 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* = object
6827 VkPhysicalDeviceFloat16Int8FeaturesKHR* = object
6828 VkPhysicalDeviceFloatControlsProperties* = object
6829 sType*: VkStructureType
6830 pNext*: pointer
6831 denormBehaviorIndependence*: VkShaderFloatControlsIndependence
6832 roundingModeIndependence*: VkShaderFloatControlsIndependence
6833 shaderSignedZeroInfNanPreserveFloat16*: VkBool32
6834 shaderSignedZeroInfNanPreserveFloat32*: VkBool32
6835 shaderSignedZeroInfNanPreserveFloat64*: VkBool32
6836 shaderDenormPreserveFloat16*: VkBool32
6837 shaderDenormPreserveFloat32*: VkBool32
6838 shaderDenormPreserveFloat64*: VkBool32
6839 shaderDenormFlushToZeroFloat16*: VkBool32
6840 shaderDenormFlushToZeroFloat32*: VkBool32
6841 shaderDenormFlushToZeroFloat64*: VkBool32
6842 shaderRoundingModeRTEFloat16*: VkBool32
6843 shaderRoundingModeRTEFloat32*: VkBool32
6844 shaderRoundingModeRTEFloat64*: VkBool32
6845 shaderRoundingModeRTZFloat16*: VkBool32
6846 shaderRoundingModeRTZFloat32*: VkBool32
6847 shaderRoundingModeRTZFloat64*: VkBool32
6848 VkPhysicalDeviceFloatControlsPropertiesKHR* = object
6849 VkPhysicalDeviceHostQueryResetFeatures* = object
6850 sType*: VkStructureType
6851 pNext*: pointer
6852 hostQueryReset*: VkBool32
6853 VkPhysicalDeviceHostQueryResetFeaturesEXT* = object
6854 VkShaderResourceUsageAMD* = object
6855 numUsedVgprs*: uint32
6856 numUsedSgprs*: uint32
6857 ldsSizePerLocalWorkGroup*: uint32
6858 ldsUsageSizeInBytes*: csize_t
6859 scratchMemUsageInBytes*: csize_t
6860 VkShaderStatisticsInfoAMD* = object
6861 shaderStageMask*: VkShaderStageFlags
6862 resourceUsage*: VkShaderResourceUsageAMD
6863 numPhysicalVgprs*: uint32
6864 numPhysicalSgprs*: uint32
6865 numAvailableVgprs*: uint32
6866 numAvailableSgprs*: uint32
6867 computeWorkGroupSize*: array[3, uint32]
6868 VkDeviceQueueGlobalPriorityCreateInfoKHR* = object
6869 sType*: VkStructureType
6870 pNext*: pointer
6871 globalPriority*: VkQueueGlobalPriorityKHR
6872 VkDeviceQueueGlobalPriorityCreateInfoEXT* = object
6873 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* = object
6874 sType*: VkStructureType
6875 pNext*: pointer
6876 globalPriorityQuery*: VkBool32
6877 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* = object
6878 VkQueueFamilyGlobalPriorityPropertiesKHR* = object
6879 sType*: VkStructureType
6880 pNext*: pointer
6881 priorityCount*: uint32
6882 priorities*: array[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR, VkQueueGlobalPriorityKHR]
6883 VkQueueFamilyGlobalPriorityPropertiesEXT* = object
6884 VkDebugUtilsObjectNameInfoEXT* = object
6885 sType*: VkStructureType
6886 pNext*: pointer
6887 objectType*: VkObjectType
6888 objectHandle*: uint64
6889 pObjectName*: cstring
6890 VkDebugUtilsObjectTagInfoEXT* = object
6891 sType*: VkStructureType
6892 pNext*: pointer
6893 objectType*: VkObjectType
6894 objectHandle*: uint64
6895 tagName*: uint64
6896 tagSize*: csize_t
6897 pTag*: pointer
6898 VkDebugUtilsLabelEXT* = object
6899 sType*: VkStructureType
6900 pNext*: pointer
6901 pLabelName*: cstring
6902 color*: array[4, float32]
6903 VkDebugUtilsMessengerCreateInfoEXT* = object
6904 sType*: VkStructureType
6905 pNext*: pointer
6906 flags*: VkDebugUtilsMessengerCreateFlagsEXT
6907 messageSeverity*: VkDebugUtilsMessageSeverityFlagsEXT
6908 messageType*: VkDebugUtilsMessageTypeFlagsEXT
6909 pfnUserCallback*: PFN_vkDebugUtilsMessengerCallbackEXT
6910 pUserData*: pointer
6911 VkDebugUtilsMessengerCallbackDataEXT* = object
6912 sType*: VkStructureType
6913 pNext*: pointer
6914 flags*: VkDebugUtilsMessengerCallbackDataFlagsEXT
6915 pMessageIdName*: cstring
6916 messageIdNumber*: int32
6917 pMessage*: cstring
6918 queueLabelCount*: uint32
6919 pQueueLabels*: ptr VkDebugUtilsLabelEXT
6920 cmdBufLabelCount*: uint32
6921 pCmdBufLabels*: ptr VkDebugUtilsLabelEXT
6922 objectCount*: uint32
6923 pObjects*: ptr VkDebugUtilsObjectNameInfoEXT
6924 VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* = object
6925 sType*: VkStructureType
6926 pNext*: pointer
6927 deviceMemoryReport*: VkBool32
6928 VkDeviceDeviceMemoryReportCreateInfoEXT* = object
6929 sType*: VkStructureType
6930 pNext*: pointer
6931 flags*: VkDeviceMemoryReportFlagsEXT
6932 pfnUserCallback*: PFN_vkDeviceMemoryReportCallbackEXT
6933 pUserData*: pointer
6934 VkDeviceMemoryReportCallbackDataEXT* = object
6935 sType*: VkStructureType
6936 pNext*: pointer
6937 flags*: VkDeviceMemoryReportFlagsEXT
6938 thetype*: VkDeviceMemoryReportEventTypeEXT
6939 memoryObjectId*: uint64
6940 size*: VkDeviceSize
6941 objectType*: VkObjectType
6942 objectHandle*: uint64
6943 heapIndex*: uint32
6944 VkImportMemoryHostPointerInfoEXT* = object
6945 sType*: VkStructureType
6946 pNext*: pointer
6947 handleType*: VkExternalMemoryHandleTypeFlagBits
6948 pHostPointer*: pointer
6949 VkMemoryHostPointerPropertiesEXT* = object
6950 sType*: VkStructureType
6951 pNext*: pointer
6952 memoryTypeBits*: uint32
6953 VkPhysicalDeviceExternalMemoryHostPropertiesEXT* = object
6954 sType*: VkStructureType
6955 pNext*: pointer
6956 minImportedHostPointerAlignment*: VkDeviceSize
6957 VkPhysicalDeviceConservativeRasterizationPropertiesEXT* = object
6958 sType*: VkStructureType
6959 pNext*: pointer
6960 primitiveOverestimationSize*: float32
6961 maxExtraPrimitiveOverestimationSize*: float32
6962 extraPrimitiveOverestimationSizeGranularity*: float32
6963 primitiveUnderestimation*: VkBool32
6964 conservativePointAndLineRasterization*: VkBool32
6965 degenerateTrianglesRasterized*: VkBool32
6966 degenerateLinesRasterized*: VkBool32
6967 fullyCoveredFragmentShaderInputVariable*: VkBool32
6968 conservativeRasterizationPostDepthCoverage*: VkBool32
6969 VkCalibratedTimestampInfoEXT* = object
6970 sType*: VkStructureType
6971 pNext*: pointer
6972 timeDomain*: VkTimeDomainEXT
6973 VkPhysicalDeviceShaderCorePropertiesAMD* = object
6974 sType*: VkStructureType
6975 pNext*: pointer
6976 shaderEngineCount*: uint32
6977 shaderArraysPerEngineCount*: uint32
6978 computeUnitsPerShaderArray*: uint32
6979 simdPerComputeUnit*: uint32
6980 wavefrontsPerSimd*: uint32
6981 wavefrontSize*: uint32
6982 sgprsPerSimd*: uint32
6983 minSgprAllocation*: uint32
6984 maxSgprAllocation*: uint32
6985 sgprAllocationGranularity*: uint32
6986 vgprsPerSimd*: uint32
6987 minVgprAllocation*: uint32
6988 maxVgprAllocation*: uint32
6989 vgprAllocationGranularity*: uint32
6990 VkPhysicalDeviceShaderCoreProperties2AMD* = object
6991 sType*: VkStructureType
6992 pNext*: pointer
6993 shaderCoreFeatures*: VkShaderCorePropertiesFlagsAMD
6994 activeComputeUnitCount*: uint32
6995 VkPipelineRasterizationConservativeStateCreateInfoEXT* = object
6996 sType*: VkStructureType
6997 pNext*: pointer
6998 flags*: VkPipelineRasterizationConservativeStateCreateFlagsEXT
6999 conservativeRasterizationMode*: VkConservativeRasterizationModeEXT
7000 extraPrimitiveOverestimationSize*: float32
7001 VkPhysicalDeviceDescriptorIndexingFeatures* = object
7002 sType*: VkStructureType
7003 pNext*: pointer
7004 shaderInputAttachmentArrayDynamicIndexing*: VkBool32
7005 shaderUniformTexelBufferArrayDynamicIndexing*: VkBool32
7006 shaderStorageTexelBufferArrayDynamicIndexing*: VkBool32
7007 shaderUniformBufferArrayNonUniformIndexing*: VkBool32
7008 shaderSampledImageArrayNonUniformIndexing*: VkBool32
7009 shaderStorageBufferArrayNonUniformIndexing*: VkBool32
7010 shaderStorageImageArrayNonUniformIndexing*: VkBool32
7011 shaderInputAttachmentArrayNonUniformIndexing*: VkBool32
7012 shaderUniformTexelBufferArrayNonUniformIndexing*: VkBool32
7013 shaderStorageTexelBufferArrayNonUniformIndexing*: VkBool32
7014 descriptorBindingUniformBufferUpdateAfterBind*: VkBool32
7015 descriptorBindingSampledImageUpdateAfterBind*: VkBool32
7016 descriptorBindingStorageImageUpdateAfterBind*: VkBool32
7017 descriptorBindingStorageBufferUpdateAfterBind*: VkBool32
7018 descriptorBindingUniformTexelBufferUpdateAfterBind*: VkBool32
7019 descriptorBindingStorageTexelBufferUpdateAfterBind*: VkBool32
7020 descriptorBindingUpdateUnusedWhilePending*: VkBool32
7021 descriptorBindingPartiallyBound*: VkBool32
7022 descriptorBindingVariableDescriptorCount*: VkBool32
7023 runtimeDescriptorArray*: VkBool32
7024 VkPhysicalDeviceDescriptorIndexingFeaturesEXT* = object
7025 VkPhysicalDeviceDescriptorIndexingProperties* = object
7026 sType*: VkStructureType
7027 pNext*: pointer
7028 maxUpdateAfterBindDescriptorsInAllPools*: uint32
7029 shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32
7030 shaderSampledImageArrayNonUniformIndexingNative*: VkBool32
7031 shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32
7032 shaderStorageImageArrayNonUniformIndexingNative*: VkBool32
7033 shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32
7034 robustBufferAccessUpdateAfterBind*: VkBool32
7035 quadDivergentImplicitLod*: VkBool32
7036 maxPerStageDescriptorUpdateAfterBindSamplers*: uint32
7037 maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32
7038 maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32
7039 maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32
7040 maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32
7041 maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32
7042 maxPerStageUpdateAfterBindResources*: uint32
7043 maxDescriptorSetUpdateAfterBindSamplers*: uint32
7044 maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32
7045 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32
7046 maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32
7047 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32
7048 maxDescriptorSetUpdateAfterBindSampledImages*: uint32
7049 maxDescriptorSetUpdateAfterBindStorageImages*: uint32
7050 maxDescriptorSetUpdateAfterBindInputAttachments*: uint32
7051 VkPhysicalDeviceDescriptorIndexingPropertiesEXT* = object
7052 VkDescriptorSetLayoutBindingFlagsCreateInfo* = object
7053 sType*: VkStructureType
7054 pNext*: pointer
7055 bindingCount*: uint32
7056 pBindingFlags*: ptr VkDescriptorBindingFlags
7057 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* = object
7058 VkDescriptorSetVariableDescriptorCountAllocateInfo* = object
7059 sType*: VkStructureType
7060 pNext*: pointer
7061 descriptorSetCount*: uint32
7062 pDescriptorCounts*: ptr uint32
7063 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* = object
7064 VkDescriptorSetVariableDescriptorCountLayoutSupport* = object
7065 sType*: VkStructureType
7066 pNext*: pointer
7067 maxVariableDescriptorCount*: uint32
7068 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* = object
7069 VkAttachmentDescription2* = object
7070 sType*: VkStructureType
7071 pNext*: pointer
7072 flags*: VkAttachmentDescriptionFlags
7073 format*: VkFormat
7074 samples*: VkSampleCountFlagBits
7075 loadOp*: VkAttachmentLoadOp
7076 storeOp*: VkAttachmentStoreOp
7077 stencilLoadOp*: VkAttachmentLoadOp
7078 stencilStoreOp*: VkAttachmentStoreOp
7079 initialLayout*: VkImageLayout
7080 finalLayout*: VkImageLayout
7081 VkAttachmentDescription2KHR* = object
7082 VkAttachmentReference2* = object
7083 sType*: VkStructureType
7084 pNext*: pointer
7085 attachment*: uint32
7086 layout*: VkImageLayout
7087 aspectMask*: VkImageAspectFlags
7088 VkAttachmentReference2KHR* = object
7089 VkSubpassDescription2* = object
7090 sType*: VkStructureType
7091 pNext*: pointer
7092 flags*: VkSubpassDescriptionFlags
7093 pipelineBindPoint*: VkPipelineBindPoint
7094 viewMask*: uint32
7095 inputAttachmentCount*: uint32
7096 pInputAttachments*: ptr VkAttachmentReference2
7097 colorAttachmentCount*: uint32
7098 pColorAttachments*: ptr VkAttachmentReference2
7099 pResolveAttachments*: ptr VkAttachmentReference2
7100 pDepthStencilAttachment*: ptr VkAttachmentReference2
7101 preserveAttachmentCount*: uint32
7102 pPreserveAttachments*: ptr uint32
7103 VkSubpassDescription2KHR* = object
7104 VkSubpassDependency2* = object
7105 sType*: VkStructureType
7106 pNext*: pointer
7107 srcSubpass*: uint32
7108 dstSubpass*: uint32
7109 srcStageMask*: VkPipelineStageFlags
7110 dstStageMask*: VkPipelineStageFlags
7111 srcAccessMask*: VkAccessFlags
7112 dstAccessMask*: VkAccessFlags
7113 dependencyFlags*: VkDependencyFlags
7114 viewOffset*: int32
7115 VkSubpassDependency2KHR* = object
7116 VkRenderPassCreateInfo2* = object
7117 sType*: VkStructureType
7118 pNext*: pointer
7119 flags*: VkRenderPassCreateFlags
7120 attachmentCount*: uint32
7121 pAttachments*: ptr VkAttachmentDescription2
7122 subpassCount*: uint32
7123 pSubpasses*: ptr VkSubpassDescription2
7124 dependencyCount*: uint32
7125 pDependencies*: ptr VkSubpassDependency2
7126 correlatedViewMaskCount*: uint32
7127 pCorrelatedViewMasks*: ptr uint32
7128 VkRenderPassCreateInfo2KHR* = object
7129 VkSubpassBeginInfo* = object
7130 sType*: VkStructureType
7131 pNext*: pointer
7132 contents*: VkSubpassContents
7133 VkSubpassBeginInfoKHR* = object
7134 VkSubpassEndInfo* = object
7135 sType*: VkStructureType
7136 pNext*: pointer
7137 VkSubpassEndInfoKHR* = object
7138 VkPhysicalDeviceTimelineSemaphoreFeatures* = object
7139 sType*: VkStructureType
7140 pNext*: pointer
7141 timelineSemaphore*: VkBool32
7142 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR* = object
7143 VkPhysicalDeviceTimelineSemaphoreProperties* = object
7144 sType*: VkStructureType
7145 pNext*: pointer
7146 maxTimelineSemaphoreValueDifference*: uint64
7147 VkPhysicalDeviceTimelineSemaphorePropertiesKHR* = object
7148 VkSemaphoreTypeCreateInfo* = object
7149 sType*: VkStructureType
7150 pNext*: pointer
7151 semaphoreType*: VkSemaphoreType
7152 initialValue*: uint64
7153 VkSemaphoreTypeCreateInfoKHR* = object
7154 VkTimelineSemaphoreSubmitInfo* = object
7155 sType*: VkStructureType
7156 pNext*: pointer
7157 waitSemaphoreValueCount*: uint32
7158 pWaitSemaphoreValues*: ptr uint64
7159 signalSemaphoreValueCount*: uint32
7160 pSignalSemaphoreValues*: ptr uint64
7161 VkTimelineSemaphoreSubmitInfoKHR* = object
7162 VkSemaphoreWaitInfo* = object
7163 sType*: VkStructureType
7164 pNext*: pointer
7165 flags*: VkSemaphoreWaitFlags
7166 semaphoreCount*: uint32
7167 pSemaphores*: ptr VkSemaphore
7168 pValues*: ptr uint64
7169 VkSemaphoreWaitInfoKHR* = object
7170 VkSemaphoreSignalInfo* = object
7171 sType*: VkStructureType
7172 pNext*: pointer
7173 semaphore*: VkSemaphore
7174 value*: uint64
7175 VkSemaphoreSignalInfoKHR* = object
7176 VkVertexInputBindingDivisorDescriptionEXT* = object
7177 binding*: uint32
7178 divisor*: uint32
7179 VkPipelineVertexInputDivisorStateCreateInfoEXT* = object
7180 sType*: VkStructureType
7181 pNext*: pointer
7182 vertexBindingDivisorCount*: uint32
7183 pVertexBindingDivisors*: ptr VkVertexInputBindingDivisorDescriptionEXT
7184 VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* = object
7185 sType*: VkStructureType
7186 pNext*: pointer
7187 maxVertexAttribDivisor*: uint32
7188 VkPhysicalDevicePCIBusInfoPropertiesEXT* = object
7189 sType*: VkStructureType
7190 pNext*: pointer
7191 pciDomain*: uint32
7192 pciBus*: uint32
7193 pciDevice*: uint32
7194 pciFunction*: uint32
7195 VkCommandBufferInheritanceConditionalRenderingInfoEXT* = object
7196 sType*: VkStructureType
7197 pNext*: pointer
7198 conditionalRenderingEnable*: VkBool32
7199 VkPhysicalDevice8BitStorageFeatures* = object
7200 sType*: VkStructureType
7201 pNext*: pointer
7202 storageBuffer8BitAccess*: VkBool32
7203 uniformAndStorageBuffer8BitAccess*: VkBool32
7204 storagePushConstant8*: VkBool32
7205 VkPhysicalDevice8BitStorageFeaturesKHR* = object
7206 VkPhysicalDeviceConditionalRenderingFeaturesEXT* = object
7207 sType*: VkStructureType
7208 pNext*: pointer
7209 conditionalRendering*: VkBool32
7210 inheritedConditionalRendering*: VkBool32
7211 VkPhysicalDeviceVulkanMemoryModelFeatures* = object
7212 sType*: VkStructureType
7213 pNext*: pointer
7214 vulkanMemoryModel*: VkBool32
7215 vulkanMemoryModelDeviceScope*: VkBool32
7216 vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32
7217 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* = object
7218 VkPhysicalDeviceShaderAtomicInt64Features* = object
7219 sType*: VkStructureType
7220 pNext*: pointer
7221 shaderBufferInt64Atomics*: VkBool32
7222 shaderSharedInt64Atomics*: VkBool32
7223 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* = object
7224 VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* = object
7225 sType*: VkStructureType
7226 pNext*: pointer
7227 shaderBufferFloat32Atomics*: VkBool32
7228 shaderBufferFloat32AtomicAdd*: VkBool32
7229 shaderBufferFloat64Atomics*: VkBool32
7230 shaderBufferFloat64AtomicAdd*: VkBool32
7231 shaderSharedFloat32Atomics*: VkBool32
7232 shaderSharedFloat32AtomicAdd*: VkBool32
7233 shaderSharedFloat64Atomics*: VkBool32
7234 shaderSharedFloat64AtomicAdd*: VkBool32
7235 shaderImageFloat32Atomics*: VkBool32
7236 shaderImageFloat32AtomicAdd*: VkBool32
7237 sparseImageFloat32Atomics*: VkBool32
7238 sparseImageFloat32AtomicAdd*: VkBool32
7239 VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* = object
7240 sType*: VkStructureType
7241 pNext*: pointer
7242 shaderBufferFloat16Atomics*: VkBool32
7243 shaderBufferFloat16AtomicAdd*: VkBool32
7244 shaderBufferFloat16AtomicMinMax*: VkBool32
7245 shaderBufferFloat32AtomicMinMax*: VkBool32
7246 shaderBufferFloat64AtomicMinMax*: VkBool32
7247 shaderSharedFloat16Atomics*: VkBool32
7248 shaderSharedFloat16AtomicAdd*: VkBool32
7249 shaderSharedFloat16AtomicMinMax*: VkBool32
7250 shaderSharedFloat32AtomicMinMax*: VkBool32
7251 shaderSharedFloat64AtomicMinMax*: VkBool32
7252 shaderImageFloat32AtomicMinMax*: VkBool32
7253 sparseImageFloat32AtomicMinMax*: VkBool32
7254 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* = object
7255 sType*: VkStructureType
7256 pNext*: pointer
7257 vertexAttributeInstanceRateDivisor*: VkBool32
7258 vertexAttributeInstanceRateZeroDivisor*: VkBool32
7259 VkQueueFamilyCheckpointPropertiesNV* = object
7260 sType*: VkStructureType
7261 pNext*: pointer
7262 checkpointExecutionStageMask*: VkPipelineStageFlags
7263 VkCheckpointDataNV* = object
7264 sType*: VkStructureType
7265 pNext*: pointer
7266 stage*: VkPipelineStageFlagBits
7267 pCheckpointMarker*: pointer
7268 VkPhysicalDeviceDepthStencilResolveProperties* = object
7269 sType*: VkStructureType
7270 pNext*: pointer
7271 supportedDepthResolveModes*: VkResolveModeFlags
7272 supportedStencilResolveModes*: VkResolveModeFlags
7273 independentResolveNone*: VkBool32
7274 independentResolve*: VkBool32
7275 VkPhysicalDeviceDepthStencilResolvePropertiesKHR* = object
7276 VkSubpassDescriptionDepthStencilResolve* = object
7277 sType*: VkStructureType
7278 pNext*: pointer
7279 depthResolveMode*: VkResolveModeFlagBits
7280 stencilResolveMode*: VkResolveModeFlagBits
7281 pDepthStencilResolveAttachment*: ptr VkAttachmentReference2
7282 VkSubpassDescriptionDepthStencilResolveKHR* = object
7283 VkImageViewASTCDecodeModeEXT* = object
7284 sType*: VkStructureType
7285 pNext*: pointer
7286 decodeMode*: VkFormat
7287 VkPhysicalDeviceASTCDecodeFeaturesEXT* = object
7288 sType*: VkStructureType
7289 pNext*: pointer
7290 decodeModeSharedExponent*: VkBool32
7291 VkPhysicalDeviceTransformFeedbackFeaturesEXT* = object
7292 sType*: VkStructureType
7293 pNext*: pointer
7294 transformFeedback*: VkBool32
7295 geometryStreams*: VkBool32
7296 VkPhysicalDeviceTransformFeedbackPropertiesEXT* = object
7297 sType*: VkStructureType
7298 pNext*: pointer
7299 maxTransformFeedbackStreams*: uint32
7300 maxTransformFeedbackBuffers*: uint32
7301 maxTransformFeedbackBufferSize*: VkDeviceSize
7302 maxTransformFeedbackStreamDataSize*: uint32
7303 maxTransformFeedbackBufferDataSize*: uint32
7304 maxTransformFeedbackBufferDataStride*: uint32
7305 transformFeedbackQueries*: VkBool32
7306 transformFeedbackStreamsLinesTriangles*: VkBool32
7307 transformFeedbackRasterizationStreamSelect*: VkBool32
7308 transformFeedbackDraw*: VkBool32
7309 VkPipelineRasterizationStateStreamCreateInfoEXT* = object
7310 sType*: VkStructureType
7311 pNext*: pointer
7312 flags*: VkPipelineRasterizationStateStreamCreateFlagsEXT
7313 rasterizationStream*: uint32
7314 VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* = object
7315 sType*: VkStructureType
7316 pNext*: pointer
7317 representativeFragmentTest*: VkBool32
7318 VkPipelineRepresentativeFragmentTestStateCreateInfoNV* = object
7319 sType*: VkStructureType
7320 pNext*: pointer
7321 representativeFragmentTestEnable*: VkBool32
7322 VkPhysicalDeviceExclusiveScissorFeaturesNV* = object
7323 sType*: VkStructureType
7324 pNext*: pointer
7325 exclusiveScissor*: VkBool32
7326 VkPipelineViewportExclusiveScissorStateCreateInfoNV* = object
7327 sType*: VkStructureType
7328 pNext*: pointer
7329 exclusiveScissorCount*: uint32
7330 pExclusiveScissors*: ptr VkRect2D
7331 VkPhysicalDeviceCornerSampledImageFeaturesNV* = object
7332 sType*: VkStructureType
7333 pNext*: pointer
7334 cornerSampledImage*: VkBool32
7335 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* = object
7336 sType*: VkStructureType
7337 pNext*: pointer
7338 computeDerivativeGroupQuads*: VkBool32
7339 computeDerivativeGroupLinear*: VkBool32
7340 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* = object
7341 VkPhysicalDeviceShaderImageFootprintFeaturesNV* = object
7342 sType*: VkStructureType
7343 pNext*: pointer
7344 imageFootprint*: VkBool32
7345 VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* = object
7346 sType*: VkStructureType
7347 pNext*: pointer
7348 dedicatedAllocationImageAliasing*: VkBool32
7349 VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* = object
7350 sType*: VkStructureType
7351 pNext*: pointer
7352 indirectCopy*: VkBool32
7353 VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* = object
7354 sType*: VkStructureType
7355 pNext*: pointer
7356 supportedQueues*: VkQueueFlags
7357 VkPhysicalDeviceMemoryDecompressionFeaturesNV* = object
7358 sType*: VkStructureType
7359 pNext*: pointer
7360 memoryDecompression*: VkBool32
7361 VkPhysicalDeviceMemoryDecompressionPropertiesNV* = object
7362 sType*: VkStructureType
7363 pNext*: pointer
7364 decompressionMethods*: VkMemoryDecompressionMethodFlagsNV
7365 maxDecompressionIndirectCount*: uint64
7366 VkShadingRatePaletteNV* = object
7367 shadingRatePaletteEntryCount*: uint32
7368 pShadingRatePaletteEntries*: ptr VkShadingRatePaletteEntryNV
7369 VkPipelineViewportShadingRateImageStateCreateInfoNV* = object
7370 sType*: VkStructureType
7371 pNext*: pointer
7372 shadingRateImageEnable*: VkBool32
7373 viewportCount*: uint32
7374 pShadingRatePalettes*: ptr VkShadingRatePaletteNV
7375 VkPhysicalDeviceShadingRateImageFeaturesNV* = object
7376 sType*: VkStructureType
7377 pNext*: pointer
7378 shadingRateImage*: VkBool32
7379 shadingRateCoarseSampleOrder*: VkBool32
7380 VkPhysicalDeviceShadingRateImagePropertiesNV* = object
7381 sType*: VkStructureType
7382 pNext*: pointer
7383 shadingRateTexelSize*: VkExtent2D
7384 shadingRatePaletteSize*: uint32
7385 shadingRateMaxCoarseSamples*: uint32
7386 VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* = object
7387 sType*: VkStructureType
7388 pNext*: pointer
7389 invocationMask*: VkBool32
7390 VkCoarseSampleLocationNV* = object
7391 pixelX*: uint32
7392 pixelY*: uint32
7393 sample*: uint32
7394 VkCoarseSampleOrderCustomNV* = object
7395 shadingRate*: VkShadingRatePaletteEntryNV
7396 sampleCount*: uint32
7397 sampleLocationCount*: uint32
7398 pSampleLocations*: ptr VkCoarseSampleLocationNV
7399 VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* = object
7400 sType*: VkStructureType
7401 pNext*: pointer
7402 sampleOrderType*: VkCoarseSampleOrderTypeNV
7403 customSampleOrderCount*: uint32
7404 pCustomSampleOrders*: ptr VkCoarseSampleOrderCustomNV
7405 VkPhysicalDeviceMeshShaderFeaturesNV* = object
7406 sType*: VkStructureType
7407 pNext*: pointer
7408 taskShader*: VkBool32
7409 meshShader*: VkBool32
7410 VkPhysicalDeviceMeshShaderPropertiesNV* = object
7411 sType*: VkStructureType
7412 pNext*: pointer
7413 maxDrawMeshTasksCount*: uint32
7414 maxTaskWorkGroupInvocations*: uint32
7415 maxTaskWorkGroupSize*: array[3, uint32]
7416 maxTaskTotalMemorySize*: uint32
7417 maxTaskOutputCount*: uint32
7418 maxMeshWorkGroupInvocations*: uint32
7419 maxMeshWorkGroupSize*: array[3, uint32]
7420 maxMeshTotalMemorySize*: uint32
7421 maxMeshOutputVertices*: uint32
7422 maxMeshOutputPrimitives*: uint32
7423 maxMeshMultiviewViewCount*: uint32
7424 meshOutputPerVertexGranularity*: uint32
7425 meshOutputPerPrimitiveGranularity*: uint32
7426 VkDrawMeshTasksIndirectCommandNV* = object
7427 taskCount*: uint32
7428 firstTask*: uint32
7429 VkPhysicalDeviceMeshShaderFeaturesEXT* = object
7430 sType*: VkStructureType
7431 pNext*: pointer
7432 taskShader*: VkBool32
7433 meshShader*: VkBool32
7434 multiviewMeshShader*: VkBool32
7435 primitiveFragmentShadingRateMeshShader*: VkBool32
7436 meshShaderQueries*: VkBool32
7437 VkPhysicalDeviceMeshShaderPropertiesEXT* = object
7438 sType*: VkStructureType
7439 pNext*: pointer
7440 maxTaskWorkGroupTotalCount*: uint32
7441 maxTaskWorkGroupCount*: array[3, uint32]
7442 maxTaskWorkGroupInvocations*: uint32
7443 maxTaskWorkGroupSize*: array[3, uint32]
7444 maxTaskPayloadSize*: uint32
7445 maxTaskSharedMemorySize*: uint32
7446 maxTaskPayloadAndSharedMemorySize*: uint32
7447 maxMeshWorkGroupTotalCount*: uint32
7448 maxMeshWorkGroupCount*: array[3, uint32]
7449 maxMeshWorkGroupInvocations*: uint32
7450 maxMeshWorkGroupSize*: array[3, uint32]
7451 maxMeshSharedMemorySize*: uint32
7452 maxMeshPayloadAndSharedMemorySize*: uint32
7453 maxMeshOutputMemorySize*: uint32
7454 maxMeshPayloadAndOutputMemorySize*: uint32
7455 maxMeshOutputComponents*: uint32
7456 maxMeshOutputVertices*: uint32
7457 maxMeshOutputPrimitives*: uint32
7458 maxMeshOutputLayers*: uint32
7459 maxMeshMultiviewViewCount*: uint32
7460 meshOutputPerVertexGranularity*: uint32
7461 meshOutputPerPrimitiveGranularity*: uint32
7462 maxPreferredTaskWorkGroupInvocations*: uint32
7463 maxPreferredMeshWorkGroupInvocations*: uint32
7464 prefersLocalInvocationVertexOutput*: VkBool32
7465 prefersLocalInvocationPrimitiveOutput*: VkBool32
7466 prefersCompactVertexOutput*: VkBool32
7467 prefersCompactPrimitiveOutput*: VkBool32
7468 VkDrawMeshTasksIndirectCommandEXT* = object
7469 groupCountX*: uint32
7470 groupCountY*: uint32
7471 groupCountZ*: uint32
7472 VkRayTracingShaderGroupCreateInfoNV* = object
7473 sType*: VkStructureType
7474 pNext*: pointer
7475 thetype*: VkRayTracingShaderGroupTypeKHR
7476 generalShader*: uint32
7477 closestHitShader*: uint32
7478 anyHitShader*: uint32
7479 intersectionShader*: uint32
7480 VkRayTracingShaderGroupCreateInfoKHR* = object
7481 sType*: VkStructureType
7482 pNext*: pointer
7483 thetype*: VkRayTracingShaderGroupTypeKHR
7484 generalShader*: uint32
7485 closestHitShader*: uint32
7486 anyHitShader*: uint32
7487 intersectionShader*: uint32
7488 pShaderGroupCaptureReplayHandle*: pointer
7489 VkRayTracingPipelineCreateInfoNV* = object
7490 sType*: VkStructureType
7491 pNext*: pointer
7492 flags*: VkPipelineCreateFlags
7493 stageCount*: uint32
7494 pStages*: ptr VkPipelineShaderStageCreateInfo
7495 groupCount*: uint32
7496 pGroups*: ptr VkRayTracingShaderGroupCreateInfoNV
7497 maxRecursionDepth*: uint32
7498 layout*: VkPipelineLayout
7499 basePipelineHandle*: VkPipeline
7500 basePipelineIndex*: int32
7501 VkRayTracingPipelineCreateInfoKHR* = object
7502 sType*: VkStructureType
7503 pNext*: pointer
7504 flags*: VkPipelineCreateFlags
7505 stageCount*: uint32
7506 pStages*: ptr VkPipelineShaderStageCreateInfo
7507 groupCount*: uint32
7508 pGroups*: ptr VkRayTracingShaderGroupCreateInfoKHR
7509 maxPipelineRayRecursionDepth*: uint32
7510 pLibraryInfo*: ptr VkPipelineLibraryCreateInfoKHR
7511 pLibraryInterface*: ptr VkRayTracingPipelineInterfaceCreateInfoKHR
7512 pDynamicState*: ptr VkPipelineDynamicStateCreateInfo
7513 layout*: VkPipelineLayout
7514 basePipelineHandle*: VkPipeline
7515 basePipelineIndex*: int32
7516 VkGeometryTrianglesNV* = object
7517 sType*: VkStructureType
7518 pNext*: pointer
7519 vertexData*: VkBuffer
7520 vertexOffset*: VkDeviceSize
7521 vertexCount*: uint32
7522 vertexStride*: VkDeviceSize
7523 vertexFormat*: VkFormat
7524 indexData*: VkBuffer
7525 indexOffset*: VkDeviceSize
7526 indexCount*: uint32
7527 indexType*: VkIndexType
7528 transformData*: VkBuffer
7529 transformOffset*: VkDeviceSize
7530 VkGeometryAABBNV* = object
7531 sType*: VkStructureType
7532 pNext*: pointer
7533 aabbData*: VkBuffer
7534 numAABBs*: uint32
7535 stride*: uint32
7536 offset*: VkDeviceSize
7537 VkGeometryDataNV* = object
7538 triangles*: VkGeometryTrianglesNV
7539 aabbs*: VkGeometryAABBNV
7540 VkGeometryNV* = object
7541 sType*: VkStructureType
7542 pNext*: pointer
7543 geometryType*: VkGeometryTypeKHR
7544 geometry*: VkGeometryDataNV
7545 flags*: VkGeometryFlagsKHR
7546 VkAccelerationStructureInfoNV* = object
7547 sType*: VkStructureType
7548 pNext*: pointer
7549 thetype*: VkAccelerationStructureTypeNV
7550 flags*: VkBuildAccelerationStructureFlagsNV
7551 instanceCount*: uint32
7552 geometryCount*: uint32
7553 pGeometries*: ptr VkGeometryNV
7554 VkAccelerationStructureCreateInfoNV* = object
7555 sType*: VkStructureType
7556 pNext*: pointer
7557 compactedSize*: VkDeviceSize
7558 info*: VkAccelerationStructureInfoNV
7559 VkBindAccelerationStructureMemoryInfoNV* = object
7560 sType*: VkStructureType
7561 pNext*: pointer
7562 accelerationStructure*: VkAccelerationStructureNV
7563 memory*: VkDeviceMemory
7564 memoryOffset*: VkDeviceSize
7565 deviceIndexCount*: uint32
7566 pDeviceIndices*: ptr uint32
7567 VkWriteDescriptorSetAccelerationStructureKHR* = object
7568 sType*: VkStructureType
7569 pNext*: pointer
7570 accelerationStructureCount*: uint32
7571 pAccelerationStructures*: ptr VkAccelerationStructureKHR
7572 VkWriteDescriptorSetAccelerationStructureNV* = object
7573 sType*: VkStructureType
7574 pNext*: pointer
7575 accelerationStructureCount*: uint32
7576 pAccelerationStructures*: ptr VkAccelerationStructureNV
7577 VkAccelerationStructureMemoryRequirementsInfoNV* = object
7578 sType*: VkStructureType
7579 pNext*: pointer
7580 thetype*: VkAccelerationStructureMemoryRequirementsTypeNV
7581 accelerationStructure*: VkAccelerationStructureNV
7582 VkPhysicalDeviceAccelerationStructureFeaturesKHR* = object
7583 sType*: VkStructureType
7584 pNext*: pointer
7585 accelerationStructure*: VkBool32
7586 accelerationStructureCaptureReplay*: VkBool32
7587 accelerationStructureIndirectBuild*: VkBool32
7588 accelerationStructureHostCommands*: VkBool32
7589 descriptorBindingAccelerationStructureUpdateAfterBind*: VkBool32
7590 VkPhysicalDeviceRayTracingPipelineFeaturesKHR* = object
7591 sType*: VkStructureType
7592 pNext*: pointer
7593 rayTracingPipeline*: VkBool32
7594 rayTracingPipelineShaderGroupHandleCaptureReplay*: VkBool32
7595 rayTracingPipelineShaderGroupHandleCaptureReplayMixed*: VkBool32
7596 rayTracingPipelineTraceRaysIndirect*: VkBool32
7597 rayTraversalPrimitiveCulling*: VkBool32
7598 VkPhysicalDeviceRayQueryFeaturesKHR* = object
7599 sType*: VkStructureType
7600 pNext*: pointer
7601 rayQuery*: VkBool32
7602 VkPhysicalDeviceAccelerationStructurePropertiesKHR* = object
7603 sType*: VkStructureType
7604 pNext*: pointer
7605 maxGeometryCount*: uint64
7606 maxInstanceCount*: uint64
7607 maxPrimitiveCount*: uint64
7608 maxPerStageDescriptorAccelerationStructures*: uint32
7609 maxPerStageDescriptorUpdateAfterBindAccelerationStructures*: uint32
7610 maxDescriptorSetAccelerationStructures*: uint32
7611 maxDescriptorSetUpdateAfterBindAccelerationStructures*: uint32
7612 minAccelerationStructureScratchOffsetAlignment*: uint32
7613 VkPhysicalDeviceRayTracingPipelinePropertiesKHR* = object
7614 sType*: VkStructureType
7615 pNext*: pointer
7616 shaderGroupHandleSize*: uint32
7617 maxRayRecursionDepth*: uint32
7618 maxShaderGroupStride*: uint32
7619 shaderGroupBaseAlignment*: uint32
7620 shaderGroupHandleCaptureReplaySize*: uint32
7621 maxRayDispatchInvocationCount*: uint32
7622 shaderGroupHandleAlignment*: uint32
7623 maxRayHitAttributeSize*: uint32
7624 VkPhysicalDeviceRayTracingPropertiesNV* = object
7625 sType*: VkStructureType
7626 pNext*: pointer
7627 shaderGroupHandleSize*: uint32
7628 maxRecursionDepth*: uint32
7629 maxShaderGroupStride*: uint32
7630 shaderGroupBaseAlignment*: uint32
7631 maxGeometryCount*: uint64
7632 maxInstanceCount*: uint64
7633 maxTriangleCount*: uint64
7634 maxDescriptorSetAccelerationStructures*: uint32
7635 VkStridedDeviceAddressRegionKHR* = object
7636 deviceAddress*: VkDeviceAddress
7637 stride*: VkDeviceSize
7638 size*: VkDeviceSize
7639 VkTraceRaysIndirectCommandKHR* = object
7640 width*: uint32
7641 height*: uint32
7642 depth*: uint32
7643 VkTraceRaysIndirectCommand2KHR* = object
7644 raygenShaderRecordAddress*: VkDeviceAddress
7645 raygenShaderRecordSize*: VkDeviceSize
7646 missShaderBindingTableAddress*: VkDeviceAddress
7647 missShaderBindingTableSize*: VkDeviceSize
7648 missShaderBindingTableStride*: VkDeviceSize
7649 hitShaderBindingTableAddress*: VkDeviceAddress
7650 hitShaderBindingTableSize*: VkDeviceSize
7651 hitShaderBindingTableStride*: VkDeviceSize
7652 callableShaderBindingTableAddress*: VkDeviceAddress
7653 callableShaderBindingTableSize*: VkDeviceSize
7654 callableShaderBindingTableStride*: VkDeviceSize
7655 width*: uint32
7656 height*: uint32
7657 depth*: uint32
7658 VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* = object
7659 sType*: VkStructureType
7660 pNext*: pointer
7661 rayTracingMaintenance1*: VkBool32
7662 rayTracingPipelineTraceRaysIndirect2*: VkBool32
7663 VkDrmFormatModifierPropertiesListEXT* = object
7664 sType*: VkStructureType
7665 pNext*: pointer
7666 drmFormatModifierCount*: uint32
7667 pDrmFormatModifierProperties*: ptr VkDrmFormatModifierPropertiesEXT
7668 VkDrmFormatModifierPropertiesEXT* = object
7669 drmFormatModifier*: uint64
7670 drmFormatModifierPlaneCount*: uint32
7671 drmFormatModifierTilingFeatures*: VkFormatFeatureFlags
7672 VkPhysicalDeviceImageDrmFormatModifierInfoEXT* = object
7673 sType*: VkStructureType
7674 pNext*: pointer
7675 drmFormatModifier*: uint64
7676 sharingMode*: VkSharingMode
7677 queueFamilyIndexCount*: uint32
7678 pQueueFamilyIndices*: ptr uint32
7679 VkImageDrmFormatModifierListCreateInfoEXT* = object
7680 sType*: VkStructureType
7681 pNext*: pointer
7682 drmFormatModifierCount*: uint32
7683 pDrmFormatModifiers*: ptr uint64
7684 VkImageDrmFormatModifierExplicitCreateInfoEXT* = object
7685 sType*: VkStructureType
7686 pNext*: pointer
7687 drmFormatModifier*: uint64
7688 drmFormatModifierPlaneCount*: uint32
7689 pPlaneLayouts*: ptr VkSubresourceLayout
7690 VkImageDrmFormatModifierPropertiesEXT* = object
7691 sType*: VkStructureType
7692 pNext*: pointer
7693 drmFormatModifier*: uint64
7694 VkImageStencilUsageCreateInfo* = object
7695 sType*: VkStructureType
7696 pNext*: pointer
7697 stencilUsage*: VkImageUsageFlags
7698 VkImageStencilUsageCreateInfoEXT* = object
7699 VkDeviceMemoryOverallocationCreateInfoAMD* = object
7700 sType*: VkStructureType
7701 pNext*: pointer
7702 overallocationBehavior*: VkMemoryOverallocationBehaviorAMD
7703 VkPhysicalDeviceFragmentDensityMapFeaturesEXT* = object
7704 sType*: VkStructureType
7705 pNext*: pointer
7706 fragmentDensityMap*: VkBool32
7707 fragmentDensityMapDynamic*: VkBool32
7708 fragmentDensityMapNonSubsampledImages*: VkBool32
7709 VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* = object
7710 sType*: VkStructureType
7711 pNext*: pointer
7712 fragmentDensityMapDeferred*: VkBool32
7713 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* = object
7714 sType*: VkStructureType
7715 pNext*: pointer
7716 fragmentDensityMapOffset*: VkBool32
7717 VkPhysicalDeviceFragmentDensityMapPropertiesEXT* = object
7718 sType*: VkStructureType
7719 pNext*: pointer
7720 minFragmentDensityTexelSize*: VkExtent2D
7721 maxFragmentDensityTexelSize*: VkExtent2D
7722 fragmentDensityInvocations*: VkBool32
7723 VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* = object
7724 sType*: VkStructureType
7725 pNext*: pointer
7726 subsampledLoads*: VkBool32
7727 subsampledCoarseReconstructionEarlyAccess*: VkBool32
7728 maxSubsampledArrayLayers*: uint32
7729 maxDescriptorSetSubsampledSamplers*: uint32
7730 VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* = object
7731 sType*: VkStructureType
7732 pNext*: pointer
7733 fragmentDensityOffsetGranularity*: VkExtent2D
7734 VkRenderPassFragmentDensityMapCreateInfoEXT* = object
7735 sType*: VkStructureType
7736 pNext*: pointer
7737 fragmentDensityMapAttachment*: VkAttachmentReference
7738 VkSubpassFragmentDensityMapOffsetEndInfoQCOM* = object
7739 sType*: VkStructureType
7740 pNext*: pointer
7741 fragmentDensityOffsetCount*: uint32
7742 pFragmentDensityOffsets*: ptr VkOffset2D
7743 VkPhysicalDeviceScalarBlockLayoutFeatures* = object
7744 sType*: VkStructureType
7745 pNext*: pointer
7746 scalarBlockLayout*: VkBool32
7747 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* = object
7748 VkSurfaceProtectedCapabilitiesKHR* = object
7749 sType*: VkStructureType
7750 pNext*: pointer
7751 supportsProtected*: VkBool32
7752 VkPhysicalDeviceUniformBufferStandardLayoutFeatures* = object
7753 sType*: VkStructureType
7754 pNext*: pointer
7755 uniformBufferStandardLayout*: VkBool32
7756 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* = object
7757 VkPhysicalDeviceDepthClipEnableFeaturesEXT* = object
7758 sType*: VkStructureType
7759 pNext*: pointer
7760 depthClipEnable*: VkBool32
7761 VkPipelineRasterizationDepthClipStateCreateInfoEXT* = object
7762 sType*: VkStructureType
7763 pNext*: pointer
7764 flags*: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
7765 depthClipEnable*: VkBool32
7766 VkPhysicalDeviceMemoryBudgetPropertiesEXT* = object
7767 sType*: VkStructureType
7768 pNext*: pointer
7769 heapBudget*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]
7770 heapUsage*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]
7771 VkPhysicalDeviceMemoryPriorityFeaturesEXT* = object
7772 sType*: VkStructureType
7773 pNext*: pointer
7774 memoryPriority*: VkBool32
7775 VkMemoryPriorityAllocateInfoEXT* = object
7776 sType*: VkStructureType
7777 pNext*: pointer
7778 priority*: float32
7779 VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* = object
7780 sType*: VkStructureType
7781 pNext*: pointer
7782 pageableDeviceLocalMemory*: VkBool32
7783 VkPhysicalDeviceBufferDeviceAddressFeatures* = object
7784 sType*: VkStructureType
7785 pNext*: pointer
7786 bufferDeviceAddress*: VkBool32
7787 bufferDeviceAddressCaptureReplay*: VkBool32
7788 bufferDeviceAddressMultiDevice*: VkBool32
7789 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR* = object
7790 VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* = object
7791 sType*: VkStructureType
7792 pNext*: pointer
7793 bufferDeviceAddress*: VkBool32
7794 bufferDeviceAddressCaptureReplay*: VkBool32
7795 bufferDeviceAddressMultiDevice*: VkBool32
7796 VkPhysicalDeviceBufferAddressFeaturesEXT* = object
7797 VkBufferDeviceAddressInfo* = object
7798 sType*: VkStructureType
7799 pNext*: pointer
7800 buffer*: VkBuffer
7801 VkBufferDeviceAddressInfoKHR* = object
7802 VkBufferDeviceAddressInfoEXT* = object
7803 VkBufferOpaqueCaptureAddressCreateInfo* = object
7804 sType*: VkStructureType
7805 pNext*: pointer
7806 opaqueCaptureAddress*: uint64
7807 VkBufferOpaqueCaptureAddressCreateInfoKHR* = object
7808 VkBufferDeviceAddressCreateInfoEXT* = object
7809 sType*: VkStructureType
7810 pNext*: pointer
7811 deviceAddress*: VkDeviceAddress
7812 VkPhysicalDeviceImageViewImageFormatInfoEXT* = object
7813 sType*: VkStructureType
7814 pNext*: pointer
7815 imageViewType*: VkImageViewType
7816 VkFilterCubicImageViewImageFormatPropertiesEXT* = object
7817 sType*: VkStructureType
7818 pNext*: pointer
7819 filterCubic*: VkBool32
7820 filterCubicMinmax*: VkBool32
7821 VkPhysicalDeviceImagelessFramebufferFeatures* = object
7822 sType*: VkStructureType
7823 pNext*: pointer
7824 imagelessFramebuffer*: VkBool32
7825 VkPhysicalDeviceImagelessFramebufferFeaturesKHR* = object
7826 VkFramebufferAttachmentsCreateInfo* = object
7827 sType*: VkStructureType
7828 pNext*: pointer
7829 attachmentImageInfoCount*: uint32
7830 pAttachmentImageInfos*: ptr VkFramebufferAttachmentImageInfo
7831 VkFramebufferAttachmentsCreateInfoKHR* = object
7832 VkFramebufferAttachmentImageInfo* = object
7833 sType*: VkStructureType
7834 pNext*: pointer
7835 flags*: VkImageCreateFlags
7836 usage*: VkImageUsageFlags
7837 width*: uint32
7838 height*: uint32
7839 layerCount*: uint32
7840 viewFormatCount*: uint32
7841 pViewFormats*: ptr VkFormat
7842 VkFramebufferAttachmentImageInfoKHR* = object
7843 VkRenderPassAttachmentBeginInfo* = object
7844 sType*: VkStructureType
7845 pNext*: pointer
7846 attachmentCount*: uint32
7847 pAttachments*: ptr VkImageView
7848 VkRenderPassAttachmentBeginInfoKHR* = object
7849 VkPhysicalDeviceTextureCompressionASTCHDRFeatures* = object
7850 sType*: VkStructureType
7851 pNext*: pointer
7852 textureCompressionASTC_HDR*: VkBool32
7853 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* = object
7854 VkPhysicalDeviceCooperativeMatrixFeaturesNV* = object
7855 sType*: VkStructureType
7856 pNext*: pointer
7857 cooperativeMatrix*: VkBool32
7858 cooperativeMatrixRobustBufferAccess*: VkBool32
7859 VkPhysicalDeviceCooperativeMatrixPropertiesNV* = object
7860 sType*: VkStructureType
7861 pNext*: pointer
7862 cooperativeMatrixSupportedStages*: VkShaderStageFlags
7863 VkCooperativeMatrixPropertiesNV* = object
7864 sType*: VkStructureType
7865 pNext*: pointer
7866 MSize*: uint32
7867 NSize*: uint32
7868 KSize*: uint32
7869 AType*: VkComponentTypeNV
7870 BType*: VkComponentTypeNV
7871 CType*: VkComponentTypeNV
7872 DType*: VkComponentTypeNV
7873 scope*: VkScopeNV
7874 VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* = object
7875 sType*: VkStructureType
7876 pNext*: pointer
7877 ycbcrImageArrays*: VkBool32
7878 VkImageViewHandleInfoNVX* = object
7879 sType*: VkStructureType
7880 pNext*: pointer
7881 imageView*: VkImageView
7882 descriptorType*: VkDescriptorType
7883 sampler*: VkSampler
7884 VkImageViewAddressPropertiesNVX* = object
7885 sType*: VkStructureType
7886 pNext*: pointer
7887 deviceAddress*: VkDeviceAddress
7888 size*: VkDeviceSize
7889 VkPipelineCreationFeedback* = object
7890 flags*: VkPipelineCreationFeedbackFlags
7891 duration*: uint64
7892 VkPipelineCreationFeedbackEXT* = object
7893 VkPipelineCreationFeedbackCreateInfo* = object
7894 sType*: VkStructureType
7895 pNext*: pointer
7896 pPipelineCreationFeedback*: ptr VkPipelineCreationFeedback
7897 pipelineStageCreationFeedbackCount*: uint32
7898 pPipelineStageCreationFeedbacks*: ptr VkPipelineCreationFeedback
7899 VkPipelineCreationFeedbackCreateInfoEXT* = object
7900 VkPhysicalDevicePresentBarrierFeaturesNV* = object
7901 sType*: VkStructureType
7902 pNext*: pointer
7903 presentBarrier*: VkBool32
7904 VkSurfaceCapabilitiesPresentBarrierNV* = object
7905 sType*: VkStructureType
7906 pNext*: pointer
7907 presentBarrierSupported*: VkBool32
7908 VkSwapchainPresentBarrierCreateInfoNV* = object
7909 sType*: VkStructureType
7910 pNext*: pointer
7911 presentBarrierEnable*: VkBool32
7912 VkPhysicalDevicePerformanceQueryFeaturesKHR* = object
7913 sType*: VkStructureType
7914 pNext*: pointer
7915 performanceCounterQueryPools*: VkBool32
7916 performanceCounterMultipleQueryPools*: VkBool32
7917 VkPhysicalDevicePerformanceQueryPropertiesKHR* = object
7918 sType*: VkStructureType
7919 pNext*: pointer
7920 allowCommandBufferQueryCopies*: VkBool32
7921 VkPerformanceCounterKHR* = object
7922 sType*: VkStructureType
7923 pNext*: pointer
7924 unit*: VkPerformanceCounterUnitKHR
7925 scope*: VkPerformanceCounterScopeKHR
7926 storage*: VkPerformanceCounterStorageKHR
7927 uuid*: array[VK_UUID_SIZE, uint8]
7928 VkPerformanceCounterDescriptionKHR* = object
7929 sType*: VkStructureType
7930 pNext*: pointer
7931 flags*: VkPerformanceCounterDescriptionFlagsKHR
7932 name*: array[VK_MAX_DESCRIPTION_SIZE, char]
7933 category*: array[VK_MAX_DESCRIPTION_SIZE, char]
7934 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
7935 VkQueryPoolPerformanceCreateInfoKHR* = object
7936 sType*: VkStructureType
7937 pNext*: pointer
7938 queueFamilyIndex*: uint32
7939 counterIndexCount*: uint32
7940 pCounterIndices*: ptr uint32
7941 VkPerformanceCounterResultKHR* {.union.} = object
7942 int32*: int32
7943 int64*: int64
7944 uint32*: uint32
7945 uint64*: uint64
7946 float32*: float32
7947 float64*: float64
7948 VkAcquireProfilingLockInfoKHR* = object
7949 sType*: VkStructureType
7950 pNext*: pointer
7951 flags*: VkAcquireProfilingLockFlagsKHR
7952 timeout*: uint64
7953 VkPerformanceQuerySubmitInfoKHR* = object
7954 sType*: VkStructureType
7955 pNext*: pointer
7956 counterPassIndex*: uint32
7957 VkPerformanceQueryReservationInfoKHR* = object
7958 sType*: VkStructureType
7959 pNext*: pointer
7960 maxPerformanceQueriesPerPool*: uint32
7961 VkHeadlessSurfaceCreateInfoEXT* = object
7962 sType*: VkStructureType
7963 pNext*: pointer
7964 flags*: VkHeadlessSurfaceCreateFlagsEXT
7965 VkPhysicalDeviceCoverageReductionModeFeaturesNV* = object
7966 sType*: VkStructureType
7967 pNext*: pointer
7968 coverageReductionMode*: VkBool32
7969 VkPipelineCoverageReductionStateCreateInfoNV* = object
7970 sType*: VkStructureType
7971 pNext*: pointer
7972 flags*: VkPipelineCoverageReductionStateCreateFlagsNV
7973 coverageReductionMode*: VkCoverageReductionModeNV
7974 VkFramebufferMixedSamplesCombinationNV* = object
7975 sType*: VkStructureType
7976 pNext*: pointer
7977 coverageReductionMode*: VkCoverageReductionModeNV
7978 rasterizationSamples*: VkSampleCountFlagBits
7979 depthStencilSamples*: VkSampleCountFlags
7980 colorSamples*: VkSampleCountFlags
7981 VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* = object
7982 sType*: VkStructureType
7983 pNext*: pointer
7984 shaderIntegerFunctions2*: VkBool32
7985 VkPerformanceValueDataINTEL* {.union.} = object
7986 value32*: uint32
7987 value64*: uint64
7988 valueFloat*: float32
7989 valueBool*: VkBool32
7990 valueString*: cstring
7991 VkPerformanceValueINTEL* = object
7992 thetype*: VkPerformanceValueTypeINTEL
7993 data*: VkPerformanceValueDataINTEL
7994 VkInitializePerformanceApiInfoINTEL* = object
7995 sType*: VkStructureType
7996 pNext*: pointer
7997 pUserData*: pointer
7998 VkQueryPoolPerformanceQueryCreateInfoINTEL* = object
7999 sType*: VkStructureType
8000 pNext*: pointer
8001 performanceCountersSampling*: VkQueryPoolSamplingModeINTEL
8002 VkQueryPoolCreateInfoINTEL* = object
8003 VkPerformanceMarkerInfoINTEL* = object
8004 sType*: VkStructureType
8005 pNext*: pointer
8006 marker*: uint64
8007 VkPerformanceStreamMarkerInfoINTEL* = object
8008 sType*: VkStructureType
8009 pNext*: pointer
8010 marker*: uint32
8011 VkPerformanceOverrideInfoINTEL* = object
8012 sType*: VkStructureType
8013 pNext*: pointer
8014 thetype*: VkPerformanceOverrideTypeINTEL
8015 enable*: VkBool32
8016 parameter*: uint64
8017 VkPerformanceConfigurationAcquireInfoINTEL* = object
8018 sType*: VkStructureType
8019 pNext*: pointer
8020 thetype*: VkPerformanceConfigurationTypeINTEL
8021 VkPhysicalDeviceShaderClockFeaturesKHR* = object
8022 sType*: VkStructureType
8023 pNext*: pointer
8024 shaderSubgroupClock*: VkBool32
8025 shaderDeviceClock*: VkBool32
8026 VkPhysicalDeviceIndexTypeUint8FeaturesEXT* = object
8027 sType*: VkStructureType
8028 pNext*: pointer
8029 indexTypeUint8*: VkBool32
8030 VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* = object
8031 sType*: VkStructureType
8032 pNext*: pointer
8033 shaderSMCount*: uint32
8034 shaderWarpsPerSM*: uint32
8035 VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* = object
8036 sType*: VkStructureType
8037 pNext*: pointer
8038 shaderSMBuiltins*: VkBool32
8039 VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* = object
8040 sType*: VkStructureType
8041 pNext*: pointer
8042 fragmentShaderSampleInterlock*: VkBool32
8043 fragmentShaderPixelInterlock*: VkBool32
8044 fragmentShaderShadingRateInterlock*: VkBool32
8045 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* = object
8046 sType*: VkStructureType
8047 pNext*: pointer
8048 separateDepthStencilLayouts*: VkBool32
8049 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR* = object
8050 VkAttachmentReferenceStencilLayout* = object
8051 sType*: VkStructureType
8052 pNext*: pointer
8053 stencilLayout*: VkImageLayout
8054 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* = object
8055 sType*: VkStructureType
8056 pNext*: pointer
8057 primitiveTopologyListRestart*: VkBool32
8058 primitiveTopologyPatchListRestart*: VkBool32
8059 VkAttachmentReferenceStencilLayoutKHR* = object
8060 VkAttachmentDescriptionStencilLayout* = object
8061 sType*: VkStructureType
8062 pNext*: pointer
8063 stencilInitialLayout*: VkImageLayout
8064 stencilFinalLayout*: VkImageLayout
8065 VkAttachmentDescriptionStencilLayoutKHR* = object
8066 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* = object
8067 sType*: VkStructureType
8068 pNext*: pointer
8069 pipelineExecutableInfo*: VkBool32
8070 VkPipelineInfoKHR* = object
8071 sType*: VkStructureType
8072 pNext*: pointer
8073 pipeline*: VkPipeline
8074 VkPipelineInfoEXT* = object
8075 VkPipelineExecutablePropertiesKHR* = object
8076 sType*: VkStructureType
8077 pNext*: pointer
8078 stages*: VkShaderStageFlags
8079 name*: array[VK_MAX_DESCRIPTION_SIZE, char]
8080 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
8081 subgroupSize*: uint32
8082 VkPipelineExecutableInfoKHR* = object
8083 sType*: VkStructureType
8084 pNext*: pointer
8085 pipeline*: VkPipeline
8086 executableIndex*: uint32
8087 VkPipelineExecutableStatisticValueKHR* {.union.} = object
8088 b32*: VkBool32
8089 i64*: int64
8090 u64*: uint64
8091 f64*: float64
8092 VkPipelineExecutableStatisticKHR* = object
8093 sType*: VkStructureType
8094 pNext*: pointer
8095 name*: array[VK_MAX_DESCRIPTION_SIZE, char]
8096 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
8097 format*: VkPipelineExecutableStatisticFormatKHR
8098 value*: VkPipelineExecutableStatisticValueKHR
8099 VkPipelineExecutableInternalRepresentationKHR* = object
8100 sType*: VkStructureType
8101 pNext*: pointer
8102 name*: array[VK_MAX_DESCRIPTION_SIZE, char]
8103 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
8104 isText*: VkBool32
8105 dataSize*: csize_t
8106 pData*: pointer
8107 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* = object
8108 sType*: VkStructureType
8109 pNext*: pointer
8110 shaderDemoteToHelperInvocation*: VkBool32
8111 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* = object
8112 VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* = object
8113 sType*: VkStructureType
8114 pNext*: pointer
8115 texelBufferAlignment*: VkBool32
8116 VkPhysicalDeviceTexelBufferAlignmentProperties* = object
8117 sType*: VkStructureType
8118 pNext*: pointer
8119 storageTexelBufferOffsetAlignmentBytes*: VkDeviceSize
8120 storageTexelBufferOffsetSingleTexelAlignment*: VkBool32
8121 uniformTexelBufferOffsetAlignmentBytes*: VkDeviceSize
8122 uniformTexelBufferOffsetSingleTexelAlignment*: VkBool32
8123 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* = object
8124 VkPhysicalDeviceSubgroupSizeControlFeatures* = object
8125 sType*: VkStructureType
8126 pNext*: pointer
8127 subgroupSizeControl*: VkBool32
8128 computeFullSubgroups*: VkBool32
8129 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* = object
8130 VkPhysicalDeviceSubgroupSizeControlProperties* = object
8131 sType*: VkStructureType
8132 pNext*: pointer
8133 minSubgroupSize*: uint32
8134 maxSubgroupSize*: uint32
8135 maxComputeWorkgroupSubgroups*: uint32
8136 requiredSubgroupSizeStages*: VkShaderStageFlags
8137 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* = object
8138 VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* = object
8139 sType*: VkStructureType
8140 pNext*: pointer
8141 requiredSubgroupSize*: uint32
8142 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* = object
8143 VkSubpassShadingPipelineCreateInfoHUAWEI* = object
8144 sType*: VkStructureType
8145 pNext*: pointer
8146 renderPass*: VkRenderPass
8147 subpass*: uint32
8148 VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* = object
8149 sType*: VkStructureType
8150 pNext*: pointer
8151 maxSubpassShadingWorkgroupSizeAspectRatio*: uint32
8152 VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* = object
8153 sType*: VkStructureType
8154 pNext*: pointer
8155 maxWorkGroupCount*: array[3, uint32]
8156 maxWorkGroupSize*: array[3, uint32]
8157 maxOutputClusterCount*: uint32
8158 VkMemoryOpaqueCaptureAddressAllocateInfo* = object
8159 sType*: VkStructureType
8160 pNext*: pointer
8161 opaqueCaptureAddress*: uint64
8162 VkMemoryOpaqueCaptureAddressAllocateInfoKHR* = object
8163 VkDeviceMemoryOpaqueCaptureAddressInfo* = object
8164 sType*: VkStructureType
8165 pNext*: pointer
8166 memory*: VkDeviceMemory
8167 VkDeviceMemoryOpaqueCaptureAddressInfoKHR* = object
8168 VkPhysicalDeviceLineRasterizationFeaturesEXT* = object
8169 sType*: VkStructureType
8170 pNext*: pointer
8171 rectangularLines*: VkBool32
8172 bresenhamLines*: VkBool32
8173 smoothLines*: VkBool32
8174 stippledRectangularLines*: VkBool32
8175 stippledBresenhamLines*: VkBool32
8176 stippledSmoothLines*: VkBool32
8177 VkPhysicalDeviceLineRasterizationPropertiesEXT* = object
8178 sType*: VkStructureType
8179 pNext*: pointer
8180 lineSubPixelPrecisionBits*: uint32
8181 VkPipelineRasterizationLineStateCreateInfoEXT* = object
8182 sType*: VkStructureType
8183 pNext*: pointer
8184 lineRasterizationMode*: VkLineRasterizationModeEXT
8185 stippledLineEnable*: VkBool32
8186 lineStippleFactor*: uint32
8187 lineStipplePattern*: uint16
8188 VkPhysicalDevicePipelineCreationCacheControlFeatures* = object
8189 sType*: VkStructureType
8190 pNext*: pointer
8191 pipelineCreationCacheControl*: VkBool32
8192 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* = object
8193 VkPhysicalDeviceVulkan11Features* = object
8194 sType*: VkStructureType
8195 pNext*: pointer
8196 storageBuffer16BitAccess*: VkBool32
8197 uniformAndStorageBuffer16BitAccess*: VkBool32
8198 storagePushConstant16*: VkBool32
8199 storageInputOutput16*: VkBool32
8200 multiview*: VkBool32
8201 multiviewGeometryShader*: VkBool32
8202 multiviewTessellationShader*: VkBool32
8203 variablePointersStorageBuffer*: VkBool32
8204 variablePointers*: VkBool32
8205 protectedMemory*: VkBool32
8206 samplerYcbcrConversion*: VkBool32
8207 shaderDrawParameters*: VkBool32
8208 VkPhysicalDeviceVulkan11Properties* = object
8209 sType*: VkStructureType
8210 pNext*: pointer
8211 deviceUUID*: array[VK_UUID_SIZE, uint8]
8212 driverUUID*: array[VK_UUID_SIZE, uint8]
8213 deviceLUID*: array[VK_LUID_SIZE, uint8]
8214 deviceNodeMask*: uint32
8215 deviceLUIDValid*: VkBool32
8216 subgroupSize*: uint32
8217 subgroupSupportedStages*: VkShaderStageFlags
8218 subgroupSupportedOperations*: VkSubgroupFeatureFlags
8219 subgroupQuadOperationsInAllStages*: VkBool32
8220 pointClippingBehavior*: VkPointClippingBehavior
8221 maxMultiviewViewCount*: uint32
8222 maxMultiviewInstanceIndex*: uint32
8223 protectedNoFault*: VkBool32
8224 maxPerSetDescriptors*: uint32
8225 maxMemoryAllocationSize*: VkDeviceSize
8226 VkPhysicalDeviceVulkan12Features* = object
8227 sType*: VkStructureType
8228 pNext*: pointer
8229 samplerMirrorClampToEdge*: VkBool32
8230 drawIndirectCount*: VkBool32
8231 storageBuffer8BitAccess*: VkBool32
8232 uniformAndStorageBuffer8BitAccess*: VkBool32
8233 storagePushConstant8*: VkBool32
8234 shaderBufferInt64Atomics*: VkBool32
8235 shaderSharedInt64Atomics*: VkBool32
8236 shaderFloat16*: VkBool32
8237 shaderInt8*: VkBool32
8238 descriptorIndexing*: VkBool32
8239 shaderInputAttachmentArrayDynamicIndexing*: VkBool32
8240 shaderUniformTexelBufferArrayDynamicIndexing*: VkBool32
8241 shaderStorageTexelBufferArrayDynamicIndexing*: VkBool32
8242 shaderUniformBufferArrayNonUniformIndexing*: VkBool32
8243 shaderSampledImageArrayNonUniformIndexing*: VkBool32
8244 shaderStorageBufferArrayNonUniformIndexing*: VkBool32
8245 shaderStorageImageArrayNonUniformIndexing*: VkBool32
8246 shaderInputAttachmentArrayNonUniformIndexing*: VkBool32
8247 shaderUniformTexelBufferArrayNonUniformIndexing*: VkBool32
8248 shaderStorageTexelBufferArrayNonUniformIndexing*: VkBool32
8249 descriptorBindingUniformBufferUpdateAfterBind*: VkBool32
8250 descriptorBindingSampledImageUpdateAfterBind*: VkBool32
8251 descriptorBindingStorageImageUpdateAfterBind*: VkBool32
8252 descriptorBindingStorageBufferUpdateAfterBind*: VkBool32
8253 descriptorBindingUniformTexelBufferUpdateAfterBind*: VkBool32
8254 descriptorBindingStorageTexelBufferUpdateAfterBind*: VkBool32
8255 descriptorBindingUpdateUnusedWhilePending*: VkBool32
8256 descriptorBindingPartiallyBound*: VkBool32
8257 descriptorBindingVariableDescriptorCount*: VkBool32
8258 runtimeDescriptorArray*: VkBool32
8259 samplerFilterMinmax*: VkBool32
8260 scalarBlockLayout*: VkBool32
8261 imagelessFramebuffer*: VkBool32
8262 uniformBufferStandardLayout*: VkBool32
8263 shaderSubgroupExtendedTypes*: VkBool32
8264 separateDepthStencilLayouts*: VkBool32
8265 hostQueryReset*: VkBool32
8266 timelineSemaphore*: VkBool32
8267 bufferDeviceAddress*: VkBool32
8268 bufferDeviceAddressCaptureReplay*: VkBool32
8269 bufferDeviceAddressMultiDevice*: VkBool32
8270 vulkanMemoryModel*: VkBool32
8271 vulkanMemoryModelDeviceScope*: VkBool32
8272 vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32
8273 shaderOutputViewportIndex*: VkBool32
8274 shaderOutputLayer*: VkBool32
8275 subgroupBroadcastDynamicId*: VkBool32
8276 VkPhysicalDeviceVulkan12Properties* = object
8277 sType*: VkStructureType
8278 pNext*: pointer
8279 driverID*: VkDriverId
8280 driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char]
8281 driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char]
8282 conformanceVersion*: VkConformanceVersion
8283 denormBehaviorIndependence*: VkShaderFloatControlsIndependence
8284 roundingModeIndependence*: VkShaderFloatControlsIndependence
8285 shaderSignedZeroInfNanPreserveFloat16*: VkBool32
8286 shaderSignedZeroInfNanPreserveFloat32*: VkBool32
8287 shaderSignedZeroInfNanPreserveFloat64*: VkBool32
8288 shaderDenormPreserveFloat16*: VkBool32
8289 shaderDenormPreserveFloat32*: VkBool32
8290 shaderDenormPreserveFloat64*: VkBool32
8291 shaderDenormFlushToZeroFloat16*: VkBool32
8292 shaderDenormFlushToZeroFloat32*: VkBool32
8293 shaderDenormFlushToZeroFloat64*: VkBool32
8294 shaderRoundingModeRTEFloat16*: VkBool32
8295 shaderRoundingModeRTEFloat32*: VkBool32
8296 shaderRoundingModeRTEFloat64*: VkBool32
8297 shaderRoundingModeRTZFloat16*: VkBool32
8298 shaderRoundingModeRTZFloat32*: VkBool32
8299 shaderRoundingModeRTZFloat64*: VkBool32
8300 maxUpdateAfterBindDescriptorsInAllPools*: uint32
8301 shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32
8302 shaderSampledImageArrayNonUniformIndexingNative*: VkBool32
8303 shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32
8304 shaderStorageImageArrayNonUniformIndexingNative*: VkBool32
8305 shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32
8306 robustBufferAccessUpdateAfterBind*: VkBool32
8307 quadDivergentImplicitLod*: VkBool32
8308 maxPerStageDescriptorUpdateAfterBindSamplers*: uint32
8309 maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32
8310 maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32
8311 maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32
8312 maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32
8313 maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32
8314 maxPerStageUpdateAfterBindResources*: uint32
8315 maxDescriptorSetUpdateAfterBindSamplers*: uint32
8316 maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32
8317 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32
8318 maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32
8319 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32
8320 maxDescriptorSetUpdateAfterBindSampledImages*: uint32
8321 maxDescriptorSetUpdateAfterBindStorageImages*: uint32
8322 maxDescriptorSetUpdateAfterBindInputAttachments*: uint32
8323 supportedDepthResolveModes*: VkResolveModeFlags
8324 supportedStencilResolveModes*: VkResolveModeFlags
8325 independentResolveNone*: VkBool32
8326 independentResolve*: VkBool32
8327 filterMinmaxSingleComponentFormats*: VkBool32
8328 filterMinmaxImageComponentMapping*: VkBool32
8329 maxTimelineSemaphoreValueDifference*: uint64
8330 framebufferIntegerColorSampleCounts*: VkSampleCountFlags
8331 VkPhysicalDeviceVulkan13Features* = object
8332 sType*: VkStructureType
8333 pNext*: pointer
8334 robustImageAccess*: VkBool32
8335 inlineUniformBlock*: VkBool32
8336 descriptorBindingInlineUniformBlockUpdateAfterBind*: VkBool32
8337 pipelineCreationCacheControl*: VkBool32
8338 privateData*: VkBool32
8339 shaderDemoteToHelperInvocation*: VkBool32
8340 shaderTerminateInvocation*: VkBool32
8341 subgroupSizeControl*: VkBool32
8342 computeFullSubgroups*: VkBool32
8343 synchronization2*: VkBool32
8344 textureCompressionASTC_HDR*: VkBool32
8345 shaderZeroInitializeWorkgroupMemory*: VkBool32
8346 dynamicRendering*: VkBool32
8347 shaderIntegerDotProduct*: VkBool32
8348 maintenance4*: VkBool32
8349 VkPhysicalDeviceVulkan13Properties* = object
8350 sType*: VkStructureType
8351 pNext*: pointer
8352 minSubgroupSize*: uint32
8353 maxSubgroupSize*: uint32
8354 maxComputeWorkgroupSubgroups*: uint32
8355 requiredSubgroupSizeStages*: VkShaderStageFlags
8356 maxInlineUniformBlockSize*: uint32
8357 maxPerStageDescriptorInlineUniformBlocks*: uint32
8358 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks*: uint32
8359 maxDescriptorSetInlineUniformBlocks*: uint32
8360 maxDescriptorSetUpdateAfterBindInlineUniformBlocks*: uint32
8361 maxInlineUniformTotalSize*: uint32
8362 integerDotProduct8BitUnsignedAccelerated*: VkBool32
8363 integerDotProduct8BitSignedAccelerated*: VkBool32
8364 integerDotProduct8BitMixedSignednessAccelerated*: VkBool32
8365 integerDotProduct4x8BitPackedUnsignedAccelerated*: VkBool32
8366 integerDotProduct4x8BitPackedSignedAccelerated*: VkBool32
8367 integerDotProduct4x8BitPackedMixedSignednessAccelerated*: VkBool32
8368 integerDotProduct16BitUnsignedAccelerated*: VkBool32
8369 integerDotProduct16BitSignedAccelerated*: VkBool32
8370 integerDotProduct16BitMixedSignednessAccelerated*: VkBool32
8371 integerDotProduct32BitUnsignedAccelerated*: VkBool32
8372 integerDotProduct32BitSignedAccelerated*: VkBool32
8373 integerDotProduct32BitMixedSignednessAccelerated*: VkBool32
8374 integerDotProduct64BitUnsignedAccelerated*: VkBool32
8375 integerDotProduct64BitSignedAccelerated*: VkBool32
8376 integerDotProduct64BitMixedSignednessAccelerated*: VkBool32
8377 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated*: VkBool32
8378 integerDotProductAccumulatingSaturating8BitSignedAccelerated*: VkBool32
8379 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated*: VkBool32
8380 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated*: VkBool32
8381 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated*: VkBool32
8382 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated*: VkBool32
8383 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated*: VkBool32
8384 integerDotProductAccumulatingSaturating16BitSignedAccelerated*: VkBool32
8385 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated*: VkBool32
8386 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated*: VkBool32
8387 integerDotProductAccumulatingSaturating32BitSignedAccelerated*: VkBool32
8388 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated*: VkBool32
8389 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated*: VkBool32
8390 integerDotProductAccumulatingSaturating64BitSignedAccelerated*: VkBool32
8391 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated*: VkBool32
8392 storageTexelBufferOffsetAlignmentBytes*: VkDeviceSize
8393 storageTexelBufferOffsetSingleTexelAlignment*: VkBool32
8394 uniformTexelBufferOffsetAlignmentBytes*: VkDeviceSize
8395 uniformTexelBufferOffsetSingleTexelAlignment*: VkBool32
8396 maxBufferSize*: VkDeviceSize
8397 VkPipelineCompilerControlCreateInfoAMD* = object
8398 sType*: VkStructureType
8399 pNext*: pointer
8400 compilerControlFlags*: VkPipelineCompilerControlFlagsAMD
8401 VkPhysicalDeviceCoherentMemoryFeaturesAMD* = object
8402 sType*: VkStructureType
8403 pNext*: pointer
8404 deviceCoherentMemory*: VkBool32
8405 VkFaultData* = object
8406 sType*: VkStructureType
8407 pNext*: pointer
8408 faultLevel*: VkFaultLevel
8409 faultType*: VkFaultType
8410 VkFaultCallbackInfo* = object
8411 sType*: VkStructureType
8412 pNext*: pointer
8413 faultCount*: uint32
8414 pFaults*: ptr VkFaultData
8415 pfnFaultCallback*: PFN_vkFaultCallbackFunction
8416 VkPhysicalDeviceToolProperties* = object
8417 sType*: VkStructureType
8418 pNext*: pointer
8419 name*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
8420 version*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
8421 purposes*: VkToolPurposeFlags
8422 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
8423 layer*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
8424 VkPhysicalDeviceToolPropertiesEXT* = object
8425 VkSamplerCustomBorderColorCreateInfoEXT* = object
8426 sType*: VkStructureType
8427 pNext*: pointer
8428 customBorderColor*: VkClearColorValue
8429 format*: VkFormat
8430 VkPhysicalDeviceCustomBorderColorPropertiesEXT* = object
8431 sType*: VkStructureType
8432 pNext*: pointer
8433 maxCustomBorderColorSamplers*: uint32
8434 VkPhysicalDeviceCustomBorderColorFeaturesEXT* = object
8435 sType*: VkStructureType
8436 pNext*: pointer
8437 customBorderColors*: VkBool32
8438 customBorderColorWithoutFormat*: VkBool32
8439 VkSamplerBorderColorComponentMappingCreateInfoEXT* = object
8440 sType*: VkStructureType
8441 pNext*: pointer
8442 components*: VkComponentMapping
8443 srgb*: VkBool32
8444 VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* = object
8445 sType*: VkStructureType
8446 pNext*: pointer
8447 borderColorSwizzle*: VkBool32
8448 borderColorSwizzleFromImage*: VkBool32
8449 VkDeviceOrHostAddressKHR* {.union.} = object
8450 deviceAddress*: VkDeviceAddress
8451 hostAddress*: pointer
8452 VkDeviceOrHostAddressConstKHR* {.union.} = object
8453 deviceAddress*: VkDeviceAddress
8454 hostAddress*: pointer
8455 VkAccelerationStructureGeometryTrianglesDataKHR* = object
8456 sType*: VkStructureType
8457 pNext*: pointer
8458 vertexFormat*: VkFormat
8459 vertexData*: VkDeviceOrHostAddressConstKHR
8460 vertexStride*: VkDeviceSize
8461 maxVertex*: uint32
8462 indexType*: VkIndexType
8463 indexData*: VkDeviceOrHostAddressConstKHR
8464 transformData*: VkDeviceOrHostAddressConstKHR
8465 VkAccelerationStructureGeometryAabbsDataKHR* = object
8466 sType*: VkStructureType
8467 pNext*: pointer
8468 data*: VkDeviceOrHostAddressConstKHR
8469 stride*: VkDeviceSize
8470 VkAccelerationStructureGeometryInstancesDataKHR* = object
8471 sType*: VkStructureType
8472 pNext*: pointer
8473 arrayOfPointers*: VkBool32
8474 data*: VkDeviceOrHostAddressConstKHR
8475 VkAccelerationStructureGeometryDataKHR* {.union.} = object
8476 triangles*: VkAccelerationStructureGeometryTrianglesDataKHR
8477 aabbs*: VkAccelerationStructureGeometryAabbsDataKHR
8478 instances*: VkAccelerationStructureGeometryInstancesDataKHR
8479 VkAccelerationStructureGeometryKHR* = object
8480 sType*: VkStructureType
8481 pNext*: pointer
8482 geometryType*: VkGeometryTypeKHR
8483 geometry*: VkAccelerationStructureGeometryDataKHR
8484 flags*: VkGeometryFlagsKHR
8485 VkAccelerationStructureBuildGeometryInfoKHR* = object
8486 sType*: VkStructureType
8487 pNext*: pointer
8488 thetype*: VkAccelerationStructureTypeKHR
8489 flags*: VkBuildAccelerationStructureFlagsKHR
8490 mode*: VkBuildAccelerationStructureModeKHR
8491 srcAccelerationStructure*: VkAccelerationStructureKHR
8492 dstAccelerationStructure*: VkAccelerationStructureKHR
8493 geometryCount*: uint32
8494 pGeometries*: ptr VkAccelerationStructureGeometryKHR
8495 ppGeometries*: ptr ptr VkAccelerationStructureGeometryKHR
8496 scratchData*: VkDeviceOrHostAddressKHR
8497 VkAccelerationStructureBuildRangeInfoKHR* = object
8498 primitiveCount*: uint32
8499 primitiveOffset*: uint32
8500 firstVertex*: uint32
8501 transformOffset*: uint32
8502 VkAccelerationStructureCreateInfoKHR* = object
8503 sType*: VkStructureType
8504 pNext*: pointer
8505 createFlags*: VkAccelerationStructureCreateFlagsKHR
8506 buffer*: VkBuffer
8507 offset*: VkDeviceSize
8508 size*: VkDeviceSize
8509 thetype*: VkAccelerationStructureTypeKHR
8510 deviceAddress*: VkDeviceAddress
8511 VkAabbPositionsKHR* = object
8512 minX*: float32
8513 minY*: float32
8514 minZ*: float32
8515 maxX*: float32
8516 maxY*: float32
8517 maxZ*: float32
8518 VkAabbPositionsNV* = object
8519 VkTransformMatrixKHR* = object
8520 matrix*: array[3*4, float32]
8521 VkTransformMatrixNV* = object
8522 VkAccelerationStructureInstanceKHR* = object
8523 transform*: VkTransformMatrixKHR
8524 instanceCustomIndex*: uint32
8525 mask*: uint32
8526 instanceShaderBindingTableRecordOffset*: uint32
8527 flags*: VkGeometryInstanceFlagsKHR
8528 accelerationStructureReference*: uint64
8529 VkAccelerationStructureInstanceNV* = object
8530 VkAccelerationStructureDeviceAddressInfoKHR* = object
8531 sType*: VkStructureType
8532 pNext*: pointer
8533 accelerationStructure*: VkAccelerationStructureKHR
8534 VkAccelerationStructureVersionInfoKHR* = object
8535 sType*: VkStructureType
8536 pNext*: pointer
8537 pVersionData*: ptr uint8
8538 VkCopyAccelerationStructureInfoKHR* = object
8539 sType*: VkStructureType
8540 pNext*: pointer
8541 src*: VkAccelerationStructureKHR
8542 dst*: VkAccelerationStructureKHR
8543 mode*: VkCopyAccelerationStructureModeKHR
8544 VkCopyAccelerationStructureToMemoryInfoKHR* = object
8545 sType*: VkStructureType
8546 pNext*: pointer
8547 src*: VkAccelerationStructureKHR
8548 dst*: VkDeviceOrHostAddressKHR
8549 mode*: VkCopyAccelerationStructureModeKHR
8550 VkCopyMemoryToAccelerationStructureInfoKHR* = object
8551 sType*: VkStructureType
8552 pNext*: pointer
8553 src*: VkDeviceOrHostAddressConstKHR
8554 dst*: VkAccelerationStructureKHR
8555 mode*: VkCopyAccelerationStructureModeKHR
8556 VkRayTracingPipelineInterfaceCreateInfoKHR* = object
8557 sType*: VkStructureType
8558 pNext*: pointer
8559 maxPipelineRayPayloadSize*: uint32
8560 maxPipelineRayHitAttributeSize*: uint32
8561 VkPipelineLibraryCreateInfoKHR* = object
8562 sType*: VkStructureType
8563 pNext*: pointer
8564 libraryCount*: uint32
8565 pLibraries*: ptr VkPipeline
8566 VkRefreshObjectKHR* = object
8567 objectType*: VkObjectType
8568 objectHandle*: uint64
8569 flags*: VkRefreshObjectFlagsKHR
8570 VkRefreshObjectListKHR* = object
8571 sType*: VkStructureType
8572 pNext*: pointer
8573 objectCount*: uint32
8574 pObjects*: ptr VkRefreshObjectKHR
8575 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* = object
8576 sType*: VkStructureType
8577 pNext*: pointer
8578 extendedDynamicState*: VkBool32
8579 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* = object
8580 sType*: VkStructureType
8581 pNext*: pointer
8582 extendedDynamicState2*: VkBool32
8583 extendedDynamicState2LogicOp*: VkBool32
8584 extendedDynamicState2PatchControlPoints*: VkBool32
8585 VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* = object
8586 sType*: VkStructureType
8587 pNext*: pointer
8588 extendedDynamicState3TessellationDomainOrigin*: VkBool32
8589 extendedDynamicState3DepthClampEnable*: VkBool32
8590 extendedDynamicState3PolygonMode*: VkBool32
8591 extendedDynamicState3RasterizationSamples*: VkBool32
8592 extendedDynamicState3SampleMask*: VkBool32
8593 extendedDynamicState3AlphaToCoverageEnable*: VkBool32
8594 extendedDynamicState3AlphaToOneEnable*: VkBool32
8595 extendedDynamicState3LogicOpEnable*: VkBool32
8596 extendedDynamicState3ColorBlendEnable*: VkBool32
8597 extendedDynamicState3ColorBlendEquation*: VkBool32
8598 extendedDynamicState3ColorWriteMask*: VkBool32
8599 extendedDynamicState3RasterizationStream*: VkBool32
8600 extendedDynamicState3ConservativeRasterizationMode*: VkBool32
8601 extendedDynamicState3ExtraPrimitiveOverestimationSize*: VkBool32
8602 extendedDynamicState3DepthClipEnable*: VkBool32
8603 extendedDynamicState3SampleLocationsEnable*: VkBool32
8604 extendedDynamicState3ColorBlendAdvanced*: VkBool32
8605 extendedDynamicState3ProvokingVertexMode*: VkBool32
8606 extendedDynamicState3LineRasterizationMode*: VkBool32
8607 extendedDynamicState3LineStippleEnable*: VkBool32
8608 extendedDynamicState3DepthClipNegativeOneToOne*: VkBool32
8609 extendedDynamicState3ViewportWScalingEnable*: VkBool32
8610 extendedDynamicState3ViewportSwizzle*: VkBool32
8611 extendedDynamicState3CoverageToColorEnable*: VkBool32
8612 extendedDynamicState3CoverageToColorLocation*: VkBool32
8613 extendedDynamicState3CoverageModulationMode*: VkBool32
8614 extendedDynamicState3CoverageModulationTableEnable*: VkBool32
8615 extendedDynamicState3CoverageModulationTable*: VkBool32
8616 extendedDynamicState3CoverageReductionMode*: VkBool32
8617 extendedDynamicState3RepresentativeFragmentTestEnable*: VkBool32
8618 extendedDynamicState3ShadingRateImageEnable*: VkBool32
8619 VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* = object
8620 sType*: VkStructureType
8621 pNext*: pointer
8622 dynamicPrimitiveTopologyUnrestricted*: VkBool32
8623 VkColorBlendEquationEXT* = object
8624 srcColorBlendFactor*: VkBlendFactor
8625 dstColorBlendFactor*: VkBlendFactor
8626 colorBlendOp*: VkBlendOp
8627 srcAlphaBlendFactor*: VkBlendFactor
8628 dstAlphaBlendFactor*: VkBlendFactor
8629 alphaBlendOp*: VkBlendOp
8630 VkColorBlendAdvancedEXT* = object
8631 advancedBlendOp*: VkBlendOp
8632 srcPremultiplied*: VkBool32
8633 dstPremultiplied*: VkBool32
8634 blendOverlap*: VkBlendOverlapEXT
8635 clampResults*: VkBool32
8636 VkRenderPassTransformBeginInfoQCOM* = object
8637 sType*: VkStructureType
8638 pNext*: pointer
8639 transform*: VkSurfaceTransformFlagBitsKHR
8640 VkCopyCommandTransformInfoQCOM* = object
8641 sType*: VkStructureType
8642 pNext*: pointer
8643 transform*: VkSurfaceTransformFlagBitsKHR
8644 VkCommandBufferInheritanceRenderPassTransformInfoQCOM* = object
8645 sType*: VkStructureType
8646 pNext*: pointer
8647 transform*: VkSurfaceTransformFlagBitsKHR
8648 renderArea*: VkRect2D
8649 VkPhysicalDeviceDiagnosticsConfigFeaturesNV* = object
8650 sType*: VkStructureType
8651 pNext*: pointer
8652 diagnosticsConfig*: VkBool32
8653 VkDeviceDiagnosticsConfigCreateInfoNV* = object
8654 sType*: VkStructureType
8655 pNext*: pointer
8656 flags*: VkDeviceDiagnosticsConfigFlagsNV
8657 VkPipelineOfflineCreateInfo* = object
8658 sType*: VkStructureType
8659 pNext*: pointer
8660 pipelineIdentifier*: array[VK_UUID_SIZE, uint8]
8661 matchControl*: VkPipelineMatchControl
8662 poolEntrySize*: VkDeviceSize
8663 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* = object
8664 sType*: VkStructureType
8665 pNext*: pointer
8666 shaderZeroInitializeWorkgroupMemory*: VkBool32
8667 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* = object
8668 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* = object
8669 sType*: VkStructureType
8670 pNext*: pointer
8671 shaderSubgroupUniformControlFlow*: VkBool32
8672 VkPhysicalDeviceRobustness2FeaturesEXT* = object
8673 sType*: VkStructureType
8674 pNext*: pointer
8675 robustBufferAccess2*: VkBool32
8676 robustImageAccess2*: VkBool32
8677 nullDescriptor*: VkBool32
8678 VkPhysicalDeviceRobustness2PropertiesEXT* = object
8679 sType*: VkStructureType
8680 pNext*: pointer
8681 robustStorageBufferAccessSizeAlignment*: VkDeviceSize
8682 robustUniformBufferAccessSizeAlignment*: VkDeviceSize
8683 VkPhysicalDeviceImageRobustnessFeatures* = object
8684 sType*: VkStructureType
8685 pNext*: pointer
8686 robustImageAccess*: VkBool32
8687 VkPhysicalDeviceImageRobustnessFeaturesEXT* = object
8688 VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* = object
8689 sType*: VkStructureType
8690 pNext*: pointer
8691 workgroupMemoryExplicitLayout*: VkBool32
8692 workgroupMemoryExplicitLayoutScalarBlockLayout*: VkBool32
8693 workgroupMemoryExplicitLayout8BitAccess*: VkBool32
8694 workgroupMemoryExplicitLayout16BitAccess*: VkBool32
8695 VkPhysicalDevice4444FormatsFeaturesEXT* = object
8696 sType*: VkStructureType
8697 pNext*: pointer
8698 formatA4R4G4B4*: VkBool32
8699 formatA4B4G4R4*: VkBool32
8700 VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* = object
8701 sType*: VkStructureType
8702 pNext*: pointer
8703 subpassShading*: VkBool32
8704 VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* = object
8705 sType*: VkStructureType
8706 pNext*: pointer
8707 clustercullingShader*: VkBool32
8708 multiviewClusterCullingShader*: VkBool32
8709 VkBufferCopy2* = object
8710 sType*: VkStructureType
8711 pNext*: pointer
8712 srcOffset*: VkDeviceSize
8713 dstOffset*: VkDeviceSize
8714 size*: VkDeviceSize
8715 VkBufferCopy2KHR* = object
8716 VkImageCopy2* = object
8717 sType*: VkStructureType
8718 pNext*: pointer
8719 srcSubresource*: VkImageSubresourceLayers
8720 srcOffset*: VkOffset3D
8721 dstSubresource*: VkImageSubresourceLayers
8722 dstOffset*: VkOffset3D
8723 extent*: VkExtent3D
8724 VkImageCopy2KHR* = object
8725 VkImageBlit2* = object
8726 sType*: VkStructureType
8727 pNext*: pointer
8728 srcSubresource*: VkImageSubresourceLayers
8729 srcOffsets*: array[2, VkOffset3D]
8730 dstSubresource*: VkImageSubresourceLayers
8731 dstOffsets*: array[2, VkOffset3D]
8732 VkImageBlit2KHR* = object
8733 VkBufferImageCopy2* = object
8734 sType*: VkStructureType
8735 pNext*: pointer
8736 bufferOffset*: VkDeviceSize
8737 bufferRowLength*: uint32
8738 bufferImageHeight*: uint32
8739 imageSubresource*: VkImageSubresourceLayers
8740 imageOffset*: VkOffset3D
8741 imageExtent*: VkExtent3D
8742 VkBufferImageCopy2KHR* = object
8743 VkImageResolve2* = object
8744 sType*: VkStructureType
8745 pNext*: pointer
8746 srcSubresource*: VkImageSubresourceLayers
8747 srcOffset*: VkOffset3D
8748 dstSubresource*: VkImageSubresourceLayers
8749 dstOffset*: VkOffset3D
8750 extent*: VkExtent3D
8751 VkImageResolve2KHR* = object
8752 VkCopyBufferInfo2* = object
8753 sType*: VkStructureType
8754 pNext*: pointer
8755 srcBuffer*: VkBuffer
8756 dstBuffer*: VkBuffer
8757 regionCount*: uint32
8758 pRegions*: ptr VkBufferCopy2
8759 VkCopyBufferInfo2KHR* = object
8760 VkCopyImageInfo2* = object
8761 sType*: VkStructureType
8762 pNext*: pointer
8763 srcImage*: VkImage
8764 srcImageLayout*: VkImageLayout
8765 dstImage*: VkImage
8766 dstImageLayout*: VkImageLayout
8767 regionCount*: uint32
8768 pRegions*: ptr VkImageCopy2
8769 VkCopyImageInfo2KHR* = object
8770 VkBlitImageInfo2* = object
8771 sType*: VkStructureType
8772 pNext*: pointer
8773 srcImage*: VkImage
8774 srcImageLayout*: VkImageLayout
8775 dstImage*: VkImage
8776 dstImageLayout*: VkImageLayout
8777 regionCount*: uint32
8778 pRegions*: ptr VkImageBlit2
8779 filter*: VkFilter
8780 VkBlitImageInfo2KHR* = object
8781 VkCopyBufferToImageInfo2* = object
8782 sType*: VkStructureType
8783 pNext*: pointer
8784 srcBuffer*: VkBuffer
8785 dstImage*: VkImage
8786 dstImageLayout*: VkImageLayout
8787 regionCount*: uint32
8788 pRegions*: ptr VkBufferImageCopy2
8789 VkCopyBufferToImageInfo2KHR* = object
8790 VkCopyImageToBufferInfo2* = object
8791 sType*: VkStructureType
8792 pNext*: pointer
8793 srcImage*: VkImage
8794 srcImageLayout*: VkImageLayout
8795 dstBuffer*: VkBuffer
8796 regionCount*: uint32
8797 pRegions*: ptr VkBufferImageCopy2
8798 VkCopyImageToBufferInfo2KHR* = object
8799 VkResolveImageInfo2* = object
8800 sType*: VkStructureType
8801 pNext*: pointer
8802 srcImage*: VkImage
8803 srcImageLayout*: VkImageLayout
8804 dstImage*: VkImage
8805 dstImageLayout*: VkImageLayout
8806 regionCount*: uint32
8807 pRegions*: ptr VkImageResolve2
8808 VkResolveImageInfo2KHR* = object
8809 VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* = object
8810 sType*: VkStructureType
8811 pNext*: pointer
8812 shaderImageInt64Atomics*: VkBool32
8813 sparseImageInt64Atomics*: VkBool32
8814 VkFragmentShadingRateAttachmentInfoKHR* = object
8815 sType*: VkStructureType
8816 pNext*: pointer
8817 pFragmentShadingRateAttachment*: ptr VkAttachmentReference2
8818 shadingRateAttachmentTexelSize*: VkExtent2D
8819 VkPipelineFragmentShadingRateStateCreateInfoKHR* = object
8820 sType*: VkStructureType
8821 pNext*: pointer
8822 fragmentSize*: VkExtent2D
8823 combinerOps*: array[2, VkFragmentShadingRateCombinerOpKHR]
8824 VkPhysicalDeviceFragmentShadingRateFeaturesKHR* = object
8825 sType*: VkStructureType
8826 pNext*: pointer
8827 pipelineFragmentShadingRate*: VkBool32
8828 primitiveFragmentShadingRate*: VkBool32
8829 attachmentFragmentShadingRate*: VkBool32
8830 VkPhysicalDeviceFragmentShadingRatePropertiesKHR* = object
8831 sType*: VkStructureType
8832 pNext*: pointer
8833 minFragmentShadingRateAttachmentTexelSize*: VkExtent2D
8834 maxFragmentShadingRateAttachmentTexelSize*: VkExtent2D
8835 maxFragmentShadingRateAttachmentTexelSizeAspectRatio*: uint32
8836 primitiveFragmentShadingRateWithMultipleViewports*: VkBool32
8837 layeredShadingRateAttachments*: VkBool32
8838 fragmentShadingRateNonTrivialCombinerOps*: VkBool32
8839 maxFragmentSize*: VkExtent2D
8840 maxFragmentSizeAspectRatio*: uint32
8841 maxFragmentShadingRateCoverageSamples*: uint32
8842 maxFragmentShadingRateRasterizationSamples*: VkSampleCountFlagBits
8843 fragmentShadingRateWithShaderDepthStencilWrites*: VkBool32
8844 fragmentShadingRateWithSampleMask*: VkBool32
8845 fragmentShadingRateWithShaderSampleMask*: VkBool32
8846 fragmentShadingRateWithConservativeRasterization*: VkBool32
8847 fragmentShadingRateWithFragmentShaderInterlock*: VkBool32
8848 fragmentShadingRateWithCustomSampleLocations*: VkBool32
8849 fragmentShadingRateStrictMultiplyCombiner*: VkBool32
8850 VkPhysicalDeviceFragmentShadingRateKHR* = object
8851 sType*: VkStructureType
8852 pNext*: pointer
8853 sampleCounts*: VkSampleCountFlags
8854 fragmentSize*: VkExtent2D
8855 VkPhysicalDeviceShaderTerminateInvocationFeatures* = object
8856 sType*: VkStructureType
8857 pNext*: pointer
8858 shaderTerminateInvocation*: VkBool32
8859 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* = object
8860 VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* = object
8861 sType*: VkStructureType
8862 pNext*: pointer
8863 fragmentShadingRateEnums*: VkBool32
8864 supersampleFragmentShadingRates*: VkBool32
8865 noInvocationFragmentShadingRates*: VkBool32
8866 VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* = object
8867 sType*: VkStructureType
8868 pNext*: pointer
8869 maxFragmentShadingRateInvocationCount*: VkSampleCountFlagBits
8870 VkPipelineFragmentShadingRateEnumStateCreateInfoNV* = object
8871 sType*: VkStructureType
8872 pNext*: pointer
8873 shadingRateType*: VkFragmentShadingRateTypeNV
8874 shadingRate*: VkFragmentShadingRateNV
8875 combinerOps*: array[2, VkFragmentShadingRateCombinerOpKHR]
8876 VkAccelerationStructureBuildSizesInfoKHR* = object
8877 sType*: VkStructureType
8878 pNext*: pointer
8879 accelerationStructureSize*: VkDeviceSize
8880 updateScratchSize*: VkDeviceSize
8881 buildScratchSize*: VkDeviceSize
8882 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* = object
8883 sType*: VkStructureType
8884 pNext*: pointer
8885 image2DViewOf3D*: VkBool32
8886 sampler2DViewOf3D*: VkBool32
8887 VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* = object
8888 sType*: VkStructureType
8889 pNext*: pointer
8890 imageSlicedViewOf3D*: VkBool32
8891 VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* = object
8892 sType*: VkStructureType
8893 pNext*: pointer
8894 mutableDescriptorType*: VkBool32
8895 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* = object
8896 VkMutableDescriptorTypeListEXT* = object
8897 descriptorTypeCount*: uint32
8898 pDescriptorTypes*: ptr VkDescriptorType
8899 VkMutableDescriptorTypeListVALVE* = object
8900 VkMutableDescriptorTypeCreateInfoEXT* = object
8901 sType*: VkStructureType
8902 pNext*: pointer
8903 mutableDescriptorTypeListCount*: uint32
8904 pMutableDescriptorTypeLists*: ptr VkMutableDescriptorTypeListEXT
8905 VkMutableDescriptorTypeCreateInfoVALVE* = object
8906 VkPhysicalDeviceDepthClipControlFeaturesEXT* = object
8907 sType*: VkStructureType
8908 pNext*: pointer
8909 depthClipControl*: VkBool32
8910 VkPipelineViewportDepthClipControlCreateInfoEXT* = object
8911 sType*: VkStructureType
8912 pNext*: pointer
8913 negativeOneToOne*: VkBool32
8914 VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* = object
8915 sType*: VkStructureType
8916 pNext*: pointer
8917 vertexInputDynamicState*: VkBool32
8918 VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* = object
8919 sType*: VkStructureType
8920 pNext*: pointer
8921 externalMemoryRDMA*: VkBool32
8922 VkVertexInputBindingDescription2EXT* = object
8923 sType*: VkStructureType
8924 pNext*: pointer
8925 binding*: uint32
8926 stride*: uint32
8927 inputRate*: VkVertexInputRate
8928 divisor*: uint32
8929 VkVertexInputAttributeDescription2EXT* = object
8930 sType*: VkStructureType
8931 pNext*: pointer
8932 location*: uint32
8933 binding*: uint32
8934 format*: VkFormat
8935 offset*: uint32
8936 VkPhysicalDeviceColorWriteEnableFeaturesEXT* = object
8937 sType*: VkStructureType
8938 pNext*: pointer
8939 colorWriteEnable*: VkBool32
8940 VkPipelineColorWriteCreateInfoEXT* = object
8941 sType*: VkStructureType
8942 pNext*: pointer
8943 attachmentCount*: uint32
8944 pColorWriteEnables*: ptr VkBool32
8945 VkMemoryBarrier2* = object
8946 sType*: VkStructureType
8947 pNext*: pointer
8948 srcStageMask*: VkPipelineStageFlags2
8949 srcAccessMask*: VkAccessFlags2
8950 dstStageMask*: VkPipelineStageFlags2
8951 dstAccessMask*: VkAccessFlags2
8952 VkMemoryBarrier2KHR* = object
8953 VkImageMemoryBarrier2* = object
8954 sType*: VkStructureType
8955 pNext*: pointer
8956 srcStageMask*: VkPipelineStageFlags2
8957 srcAccessMask*: VkAccessFlags2
8958 dstStageMask*: VkPipelineStageFlags2
8959 dstAccessMask*: VkAccessFlags2
8960 oldLayout*: VkImageLayout
8961 newLayout*: VkImageLayout
8962 srcQueueFamilyIndex*: uint32
8963 dstQueueFamilyIndex*: uint32
8964 image*: VkImage
8965 subresourceRange*: VkImageSubresourceRange
8966 VkImageMemoryBarrier2KHR* = object
8967 VkBufferMemoryBarrier2* = object
8968 sType*: VkStructureType
8969 pNext*: pointer
8970 srcStageMask*: VkPipelineStageFlags2
8971 srcAccessMask*: VkAccessFlags2
8972 dstStageMask*: VkPipelineStageFlags2
8973 dstAccessMask*: VkAccessFlags2
8974 srcQueueFamilyIndex*: uint32
8975 dstQueueFamilyIndex*: uint32
8976 buffer*: VkBuffer
8977 offset*: VkDeviceSize
8978 size*: VkDeviceSize
8979 VkBufferMemoryBarrier2KHR* = object
8980 VkDependencyInfo* = object
8981 sType*: VkStructureType
8982 pNext*: pointer
8983 dependencyFlags*: VkDependencyFlags
8984 memoryBarrierCount*: uint32
8985 pMemoryBarriers*: ptr VkMemoryBarrier2
8986 bufferMemoryBarrierCount*: uint32
8987 pBufferMemoryBarriers*: ptr VkBufferMemoryBarrier2
8988 imageMemoryBarrierCount*: uint32
8989 pImageMemoryBarriers*: ptr VkImageMemoryBarrier2
8990 VkDependencyInfoKHR* = object
8991 VkSemaphoreSubmitInfo* = object
8992 sType*: VkStructureType
8993 pNext*: pointer
8994 semaphore*: VkSemaphore
8995 value*: uint64
8996 stageMask*: VkPipelineStageFlags2
8997 deviceIndex*: uint32
8998 VkSemaphoreSubmitInfoKHR* = object
8999 VkCommandBufferSubmitInfo* = object
9000 sType*: VkStructureType
9001 pNext*: pointer
9002 commandBuffer*: VkCommandBuffer
9003 deviceMask*: uint32
9004 VkCommandBufferSubmitInfoKHR* = object
9005 VkSubmitInfo2* = object
9006 sType*: VkStructureType
9007 pNext*: pointer
9008 flags*: VkSubmitFlags
9009 waitSemaphoreInfoCount*: uint32
9010 pWaitSemaphoreInfos*: ptr VkSemaphoreSubmitInfo
9011 commandBufferInfoCount*: uint32
9012 pCommandBufferInfos*: ptr VkCommandBufferSubmitInfo
9013 signalSemaphoreInfoCount*: uint32
9014 pSignalSemaphoreInfos*: ptr VkSemaphoreSubmitInfo
9015 VkSubmitInfo2KHR* = object
9016 VkQueueFamilyCheckpointProperties2NV* = object
9017 sType*: VkStructureType
9018 pNext*: pointer
9019 checkpointExecutionStageMask*: VkPipelineStageFlags2
9020 VkCheckpointData2NV* = object
9021 sType*: VkStructureType
9022 pNext*: pointer
9023 stage*: VkPipelineStageFlags2
9024 pCheckpointMarker*: pointer
9025 VkPhysicalDeviceSynchronization2Features* = object
9026 sType*: VkStructureType
9027 pNext*: pointer
9028 synchronization2*: VkBool32
9029 VkPhysicalDeviceSynchronization2FeaturesKHR* = object
9030 VkPhysicalDeviceVulkanSC10Properties* = object
9031 sType*: VkStructureType
9032 pNext*: pointer
9033 deviceNoDynamicHostAllocations*: VkBool32
9034 deviceDestroyFreesMemory*: VkBool32
9035 commandPoolMultipleCommandBuffersRecording*: VkBool32
9036 commandPoolResetCommandBuffer*: VkBool32
9037 commandBufferSimultaneousUse*: VkBool32
9038 secondaryCommandBufferNullOrImagelessFramebuffer*: VkBool32
9039 recycleDescriptorSetMemory*: VkBool32
9040 recyclePipelineMemory*: VkBool32
9041 maxRenderPassSubpasses*: uint32
9042 maxRenderPassDependencies*: uint32
9043 maxSubpassInputAttachments*: uint32
9044 maxSubpassPreserveAttachments*: uint32
9045 maxFramebufferAttachments*: uint32
9046 maxDescriptorSetLayoutBindings*: uint32
9047 maxQueryFaultCount*: uint32
9048 maxCallbackFaultCount*: uint32
9049 maxCommandPoolCommandBuffers*: uint32
9050 maxCommandBufferSize*: VkDeviceSize
9051 VkPipelinePoolSize* = object
9052 sType*: VkStructureType
9053 pNext*: pointer
9054 poolEntrySize*: VkDeviceSize
9055 poolEntryCount*: uint32
9056 VkDeviceObjectReservationCreateInfo* = object
9057 sType*: VkStructureType
9058 pNext*: pointer
9059 pipelineCacheCreateInfoCount*: uint32
9060 pPipelineCacheCreateInfos*: ptr VkPipelineCacheCreateInfo
9061 pipelinePoolSizeCount*: uint32
9062 pPipelinePoolSizes*: ptr VkPipelinePoolSize
9063 semaphoreRequestCount*: uint32
9064 commandBufferRequestCount*: uint32
9065 fenceRequestCount*: uint32
9066 deviceMemoryRequestCount*: uint32
9067 bufferRequestCount*: uint32
9068 imageRequestCount*: uint32
9069 eventRequestCount*: uint32
9070 queryPoolRequestCount*: uint32
9071 bufferViewRequestCount*: uint32
9072 imageViewRequestCount*: uint32
9073 layeredImageViewRequestCount*: uint32
9074 pipelineCacheRequestCount*: uint32
9075 pipelineLayoutRequestCount*: uint32
9076 renderPassRequestCount*: uint32
9077 graphicsPipelineRequestCount*: uint32
9078 computePipelineRequestCount*: uint32
9079 descriptorSetLayoutRequestCount*: uint32
9080 samplerRequestCount*: uint32
9081 descriptorPoolRequestCount*: uint32
9082 descriptorSetRequestCount*: uint32
9083 framebufferRequestCount*: uint32
9084 commandPoolRequestCount*: uint32
9085 samplerYcbcrConversionRequestCount*: uint32
9086 surfaceRequestCount*: uint32
9087 swapchainRequestCount*: uint32
9088 displayModeRequestCount*: uint32
9089 subpassDescriptionRequestCount*: uint32
9090 attachmentDescriptionRequestCount*: uint32
9091 descriptorSetLayoutBindingRequestCount*: uint32
9092 descriptorSetLayoutBindingLimit*: uint32
9093 maxImageViewMipLevels*: uint32
9094 maxImageViewArrayLayers*: uint32
9095 maxLayeredImageViewMipLevels*: uint32
9096 maxOcclusionQueriesPerPool*: uint32
9097 maxPipelineStatisticsQueriesPerPool*: uint32
9098 maxTimestampQueriesPerPool*: uint32
9099 maxImmutableSamplersPerDescriptorSetLayout*: uint32
9100 VkCommandPoolMemoryReservationCreateInfo* = object
9101 sType*: VkStructureType
9102 pNext*: pointer
9103 commandPoolReservedSize*: VkDeviceSize
9104 commandPoolMaxCommandBuffers*: uint32
9105 VkCommandPoolMemoryConsumption* = object
9106 sType*: VkStructureType
9107 pNext*: pointer
9108 commandPoolAllocated*: VkDeviceSize
9109 commandPoolReservedSize*: VkDeviceSize
9110 commandBufferAllocated*: VkDeviceSize
9111 VkPhysicalDeviceVulkanSC10Features* = object
9112 sType*: VkStructureType
9113 pNext*: pointer
9114 shaderAtomicInstructions*: VkBool32
9115 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* = object
9116 sType*: VkStructureType
9117 pNext*: pointer
9118 primitivesGeneratedQuery*: VkBool32
9119 primitivesGeneratedQueryWithRasterizerDiscard*: VkBool32
9120 primitivesGeneratedQueryWithNonZeroStreams*: VkBool32
9121 VkPhysicalDeviceLegacyDitheringFeaturesEXT* = object
9122 sType*: VkStructureType
9123 pNext*: pointer
9124 legacyDithering*: VkBool32
9125 VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* = object
9126 sType*: VkStructureType
9127 pNext*: pointer
9128 multisampledRenderToSingleSampled*: VkBool32
9129 VkSubpassResolvePerformanceQueryEXT* = object
9130 sType*: VkStructureType
9131 pNext*: pointer
9132 optimal*: VkBool32
9133 VkMultisampledRenderToSingleSampledInfoEXT* = object
9134 sType*: VkStructureType
9135 pNext*: pointer
9136 multisampledRenderToSingleSampledEnable*: VkBool32
9137 rasterizationSamples*: VkSampleCountFlagBits
9138 VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* = object
9139 sType*: VkStructureType
9140 pNext*: pointer
9141 pipelineProtectedAccess*: VkBool32
9142 VkPhysicalDeviceInheritedViewportScissorFeaturesNV* = object
9143 sType*: VkStructureType
9144 pNext*: pointer
9145 inheritedViewportScissor2D*: VkBool32
9146 VkCommandBufferInheritanceViewportScissorInfoNV* = object
9147 sType*: VkStructureType
9148 pNext*: pointer
9149 viewportScissor2D*: VkBool32
9150 viewportDepthCount*: uint32
9151 pViewportDepths*: ptr VkViewport
9152 VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* = object
9153 sType*: VkStructureType
9154 pNext*: pointer
9155 ycbcr2plane444Formats*: VkBool32
9156 VkPhysicalDeviceProvokingVertexFeaturesEXT* = object
9157 sType*: VkStructureType
9158 pNext*: pointer
9159 provokingVertexLast*: VkBool32
9160 transformFeedbackPreservesProvokingVertex*: VkBool32
9161 VkPhysicalDeviceProvokingVertexPropertiesEXT* = object
9162 sType*: VkStructureType
9163 pNext*: pointer
9164 provokingVertexModePerPipeline*: VkBool32
9165 transformFeedbackPreservesTriangleFanProvokingVertex*: VkBool32
9166 VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* = object
9167 sType*: VkStructureType
9168 pNext*: pointer
9169 provokingVertexMode*: VkProvokingVertexModeEXT
9170 VkCuModuleCreateInfoNVX* = object
9171 sType*: VkStructureType
9172 pNext*: pointer
9173 dataSize*: csize_t
9174 pData*: pointer
9175 VkCuFunctionCreateInfoNVX* = object
9176 sType*: VkStructureType
9177 pNext*: pointer
9178 module*: VkCuModuleNVX
9179 pName*: cstring
9180 VkCuLaunchInfoNVX* = object
9181 sType*: VkStructureType
9182 pNext*: pointer
9183 function*: VkCuFunctionNVX
9184 gridDimX*: uint32
9185 gridDimY*: uint32
9186 gridDimZ*: uint32
9187 blockDimX*: uint32
9188 blockDimY*: uint32
9189 blockDimZ*: uint32
9190 sharedMemBytes*: uint32
9191 paramCount*: csize_t
9192 pParams*: ptr pointer
9193 extraCount*: csize_t
9194 pExtras*: ptr pointer
9195 VkPhysicalDeviceDescriptorBufferFeaturesEXT* = object
9196 sType*: VkStructureType
9197 pNext*: pointer
9198 descriptorBuffer*: VkBool32
9199 descriptorBufferCaptureReplay*: VkBool32
9200 descriptorBufferImageLayoutIgnored*: VkBool32
9201 descriptorBufferPushDescriptors*: VkBool32
9202 VkPhysicalDeviceDescriptorBufferPropertiesEXT* = object
9203 sType*: VkStructureType
9204 pNext*: pointer
9205 combinedImageSamplerDescriptorSingleArray*: VkBool32
9206 bufferlessPushDescriptors*: VkBool32
9207 allowSamplerImageViewPostSubmitCreation*: VkBool32
9208 descriptorBufferOffsetAlignment*: VkDeviceSize
9209 maxDescriptorBufferBindings*: uint32
9210 maxResourceDescriptorBufferBindings*: uint32
9211 maxSamplerDescriptorBufferBindings*: uint32
9212 maxEmbeddedImmutableSamplerBindings*: uint32
9213 maxEmbeddedImmutableSamplers*: uint32
9214 bufferCaptureReplayDescriptorDataSize*: csize_t
9215 imageCaptureReplayDescriptorDataSize*: csize_t
9216 imageViewCaptureReplayDescriptorDataSize*: csize_t
9217 samplerCaptureReplayDescriptorDataSize*: csize_t
9218 accelerationStructureCaptureReplayDescriptorDataSize*: csize_t
9219 samplerDescriptorSize*: csize_t
9220 combinedImageSamplerDescriptorSize*: csize_t
9221 sampledImageDescriptorSize*: csize_t
9222 storageImageDescriptorSize*: csize_t
9223 uniformTexelBufferDescriptorSize*: csize_t
9224 robustUniformTexelBufferDescriptorSize*: csize_t
9225 storageTexelBufferDescriptorSize*: csize_t
9226 robustStorageTexelBufferDescriptorSize*: csize_t
9227 uniformBufferDescriptorSize*: csize_t
9228 robustUniformBufferDescriptorSize*: csize_t
9229 storageBufferDescriptorSize*: csize_t
9230 robustStorageBufferDescriptorSize*: csize_t
9231 inputAttachmentDescriptorSize*: csize_t
9232 accelerationStructureDescriptorSize*: csize_t
9233 maxSamplerDescriptorBufferRange*: VkDeviceSize
9234 maxResourceDescriptorBufferRange*: VkDeviceSize
9235 samplerDescriptorBufferAddressSpaceSize*: VkDeviceSize
9236 resourceDescriptorBufferAddressSpaceSize*: VkDeviceSize
9237 descriptorBufferAddressSpaceSize*: VkDeviceSize
9238 VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* = object
9239 sType*: VkStructureType
9240 pNext*: pointer
9241 combinedImageSamplerDensityMapDescriptorSize*: csize_t
9242 VkDescriptorAddressInfoEXT* = object
9243 sType*: VkStructureType
9244 pNext*: pointer
9245 address*: VkDeviceAddress
9246 range*: VkDeviceSize
9247 format*: VkFormat
9248 VkDescriptorBufferBindingInfoEXT* = object
9249 sType*: VkStructureType
9250 pNext*: pointer
9251 address*: VkDeviceAddress
9252 usage*: VkBufferUsageFlags
9253 VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* = object
9254 sType*: VkStructureType
9255 pNext*: pointer
9256 buffer*: VkBuffer
9257 VkDescriptorDataEXT* {.union.} = object
9258 pSampler*: ptr VkSampler
9259 pCombinedImageSampler*: ptr VkDescriptorImageInfo
9260 pInputAttachmentImage*: ptr VkDescriptorImageInfo
9261 pSampledImage*: ptr VkDescriptorImageInfo
9262 pStorageImage*: ptr VkDescriptorImageInfo
9263 pUniformTexelBuffer*: ptr VkDescriptorAddressInfoEXT
9264 pStorageTexelBuffer*: ptr VkDescriptorAddressInfoEXT
9265 pUniformBuffer*: ptr VkDescriptorAddressInfoEXT
9266 pStorageBuffer*: ptr VkDescriptorAddressInfoEXT
9267 accelerationStructure*: VkDeviceAddress
9268 VkDescriptorGetInfoEXT* = object
9269 sType*: VkStructureType
9270 pNext*: pointer
9271 thetype*: VkDescriptorType
9272 data*: VkDescriptorDataEXT
9273 VkBufferCaptureDescriptorDataInfoEXT* = object
9274 sType*: VkStructureType
9275 pNext*: pointer
9276 buffer*: VkBuffer
9277 VkImageCaptureDescriptorDataInfoEXT* = object
9278 sType*: VkStructureType
9279 pNext*: pointer
9280 image*: VkImage
9281 VkImageViewCaptureDescriptorDataInfoEXT* = object
9282 sType*: VkStructureType
9283 pNext*: pointer
9284 imageView*: VkImageView
9285 VkSamplerCaptureDescriptorDataInfoEXT* = object
9286 sType*: VkStructureType
9287 pNext*: pointer
9288 sampler*: VkSampler
9289 VkAccelerationStructureCaptureDescriptorDataInfoEXT* = object
9290 sType*: VkStructureType
9291 pNext*: pointer
9292 accelerationStructure*: VkAccelerationStructureKHR
9293 accelerationStructureNV*: VkAccelerationStructureNV
9294 VkOpaqueCaptureDescriptorDataCreateInfoEXT* = object
9295 sType*: VkStructureType
9296 pNext*: pointer
9297 opaqueCaptureDescriptorData*: pointer
9298 VkPhysicalDeviceShaderIntegerDotProductFeatures* = object
9299 sType*: VkStructureType
9300 pNext*: pointer
9301 shaderIntegerDotProduct*: VkBool32
9302 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* = object
9303 VkPhysicalDeviceShaderIntegerDotProductProperties* = object
9304 sType*: VkStructureType
9305 pNext*: pointer
9306 integerDotProduct8BitUnsignedAccelerated*: VkBool32
9307 integerDotProduct8BitSignedAccelerated*: VkBool32
9308 integerDotProduct8BitMixedSignednessAccelerated*: VkBool32
9309 integerDotProduct4x8BitPackedUnsignedAccelerated*: VkBool32
9310 integerDotProduct4x8BitPackedSignedAccelerated*: VkBool32
9311 integerDotProduct4x8BitPackedMixedSignednessAccelerated*: VkBool32
9312 integerDotProduct16BitUnsignedAccelerated*: VkBool32
9313 integerDotProduct16BitSignedAccelerated*: VkBool32
9314 integerDotProduct16BitMixedSignednessAccelerated*: VkBool32
9315 integerDotProduct32BitUnsignedAccelerated*: VkBool32
9316 integerDotProduct32BitSignedAccelerated*: VkBool32
9317 integerDotProduct32BitMixedSignednessAccelerated*: VkBool32
9318 integerDotProduct64BitUnsignedAccelerated*: VkBool32
9319 integerDotProduct64BitSignedAccelerated*: VkBool32
9320 integerDotProduct64BitMixedSignednessAccelerated*: VkBool32
9321 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated*: VkBool32
9322 integerDotProductAccumulatingSaturating8BitSignedAccelerated*: VkBool32
9323 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated*: VkBool32
9324 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated*: VkBool32
9325 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated*: VkBool32
9326 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated*: VkBool32
9327 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated*: VkBool32
9328 integerDotProductAccumulatingSaturating16BitSignedAccelerated*: VkBool32
9329 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated*: VkBool32
9330 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated*: VkBool32
9331 integerDotProductAccumulatingSaturating32BitSignedAccelerated*: VkBool32
9332 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated*: VkBool32
9333 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated*: VkBool32
9334 integerDotProductAccumulatingSaturating64BitSignedAccelerated*: VkBool32
9335 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated*: VkBool32
9336 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* = object
9337 VkPhysicalDeviceDrmPropertiesEXT* = object
9338 sType*: VkStructureType
9339 pNext*: pointer
9340 hasPrimary*: VkBool32
9341 hasRender*: VkBool32
9342 primaryMajor*: int64
9343 primaryMinor*: int64
9344 renderMajor*: int64
9345 renderMinor*: int64
9346 VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* = object
9347 sType*: VkStructureType
9348 pNext*: pointer
9349 fragmentShaderBarycentric*: VkBool32
9350 VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* = object
9351 sType*: VkStructureType
9352 pNext*: pointer
9353 triStripVertexOrderIndependentOfProvokingVertex*: VkBool32
9354 VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* = object
9355 sType*: VkStructureType
9356 pNext*: pointer
9357 rayTracingMotionBlur*: VkBool32
9358 rayTracingMotionBlurPipelineTraceRaysIndirect*: VkBool32
9359 VkAccelerationStructureGeometryMotionTrianglesDataNV* = object
9360 sType*: VkStructureType
9361 pNext*: pointer
9362 vertexData*: VkDeviceOrHostAddressConstKHR
9363 VkAccelerationStructureMotionInfoNV* = object
9364 sType*: VkStructureType
9365 pNext*: pointer
9366 maxInstances*: uint32
9367 flags*: VkAccelerationStructureMotionInfoFlagsNV
9368 VkSRTDataNV* = object
9369 sx*: float32
9370 a*: float32
9371 b*: float32
9372 pvx*: float32
9373 sy*: float32
9374 c*: float32
9375 pvy*: float32
9376 sz*: float32
9377 pvz*: float32
9378 qx*: float32
9379 qy*: float32
9380 qz*: float32
9381 qw*: float32
9382 tx*: float32
9383 ty*: float32
9384 tz*: float32
9385 VkAccelerationStructureSRTMotionInstanceNV* = object
9386 transformT0*: VkSRTDataNV
9387 transformT1*: VkSRTDataNV
9388 instanceCustomIndex*: uint32
9389 mask*: uint32
9390 instanceShaderBindingTableRecordOffset*: uint32
9391 flags*: VkGeometryInstanceFlagsKHR
9392 accelerationStructureReference*: uint64
9393 VkAccelerationStructureMatrixMotionInstanceNV* = object
9394 transformT0*: VkTransformMatrixKHR
9395 transformT1*: VkTransformMatrixKHR
9396 instanceCustomIndex*: uint32
9397 mask*: uint32
9398 instanceShaderBindingTableRecordOffset*: uint32
9399 flags*: VkGeometryInstanceFlagsKHR
9400 accelerationStructureReference*: uint64
9401 VkAccelerationStructureMotionInstanceDataNV* {.union.} = object
9402 staticInstance*: VkAccelerationStructureInstanceKHR
9403 matrixMotionInstance*: VkAccelerationStructureMatrixMotionInstanceNV
9404 srtMotionInstance*: VkAccelerationStructureSRTMotionInstanceNV
9405 VkAccelerationStructureMotionInstanceNV* = object
9406 thetype*: VkAccelerationStructureMotionInstanceTypeNV
9407 flags*: VkAccelerationStructureMotionInstanceFlagsNV
9408 data*: VkAccelerationStructureMotionInstanceDataNV
9409 VkMemoryGetRemoteAddressInfoNV* = object
9410 sType*: VkStructureType
9411 pNext*: pointer
9412 memory*: VkDeviceMemory
9413 handleType*: VkExternalMemoryHandleTypeFlagBits
9414 VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* = object
9415 sType*: VkStructureType
9416 pNext*: pointer
9417 formatRgba10x6WithoutYCbCrSampler*: VkBool32
9418 VkFormatProperties3* = object
9419 sType*: VkStructureType
9420 pNext*: pointer
9421 linearTilingFeatures*: VkFormatFeatureFlags2
9422 optimalTilingFeatures*: VkFormatFeatureFlags2
9423 bufferFeatures*: VkFormatFeatureFlags2
9424 VkFormatProperties3KHR* = object
9425 VkDrmFormatModifierPropertiesList2EXT* = object
9426 sType*: VkStructureType
9427 pNext*: pointer
9428 drmFormatModifierCount*: uint32
9429 pDrmFormatModifierProperties*: ptr VkDrmFormatModifierProperties2EXT
9430 VkDrmFormatModifierProperties2EXT* = object
9431 drmFormatModifier*: uint64
9432 drmFormatModifierPlaneCount*: uint32
9433 drmFormatModifierTilingFeatures*: VkFormatFeatureFlags2
9434 VkPipelineRenderingCreateInfo* = object
9435 sType*: VkStructureType
9436 pNext*: pointer
9437 viewMask*: uint32
9438 colorAttachmentCount*: uint32
9439 pColorAttachmentFormats*: ptr VkFormat
9440 depthAttachmentFormat*: VkFormat
9441 stencilAttachmentFormat*: VkFormat
9442 VkPipelineRenderingCreateInfoKHR* = object
9443 VkRenderingInfo* = object
9444 sType*: VkStructureType
9445 pNext*: pointer
9446 flags*: VkRenderingFlags
9447 renderArea*: VkRect2D
9448 layerCount*: uint32
9449 viewMask*: uint32
9450 colorAttachmentCount*: uint32
9451 pColorAttachments*: ptr VkRenderingAttachmentInfo
9452 pDepthAttachment*: ptr VkRenderingAttachmentInfo
9453 pStencilAttachment*: ptr VkRenderingAttachmentInfo
9454 VkRenderingInfoKHR* = object
9455 VkRenderingAttachmentInfo* = object
9456 sType*: VkStructureType
9457 pNext*: pointer
9458 imageView*: VkImageView
9459 imageLayout*: VkImageLayout
9460 resolveMode*: VkResolveModeFlagBits
9461 resolveImageView*: VkImageView
9462 resolveImageLayout*: VkImageLayout
9463 loadOp*: VkAttachmentLoadOp
9464 storeOp*: VkAttachmentStoreOp
9465 clearValue*: VkClearValue
9466 VkRenderingAttachmentInfoKHR* = object
9467 VkRenderingFragmentShadingRateAttachmentInfoKHR* = object
9468 sType*: VkStructureType
9469 pNext*: pointer
9470 imageView*: VkImageView
9471 imageLayout*: VkImageLayout
9472 shadingRateAttachmentTexelSize*: VkExtent2D
9473 VkRenderingFragmentDensityMapAttachmentInfoEXT* = object
9474 sType*: VkStructureType
9475 pNext*: pointer
9476 imageView*: VkImageView
9477 imageLayout*: VkImageLayout
9478 VkPhysicalDeviceDynamicRenderingFeatures* = object
9479 sType*: VkStructureType
9480 pNext*: pointer
9481 dynamicRendering*: VkBool32
9482 VkPhysicalDeviceDynamicRenderingFeaturesKHR* = object
9483 VkCommandBufferInheritanceRenderingInfo* = object
9484 sType*: VkStructureType
9485 pNext*: pointer
9486 flags*: VkRenderingFlags
9487 viewMask*: uint32
9488 colorAttachmentCount*: uint32
9489 pColorAttachmentFormats*: ptr VkFormat
9490 depthAttachmentFormat*: VkFormat
9491 stencilAttachmentFormat*: VkFormat
9492 rasterizationSamples*: VkSampleCountFlagBits
9493 VkCommandBufferInheritanceRenderingInfoKHR* = object
9494 VkAttachmentSampleCountInfoAMD* = object
9495 sType*: VkStructureType
9496 pNext*: pointer
9497 colorAttachmentCount*: uint32
9498 pColorAttachmentSamples*: ptr VkSampleCountFlagBits
9499 depthStencilAttachmentSamples*: VkSampleCountFlagBits
9500 VkAttachmentSampleCountInfoNV* = object
9501 VkMultiviewPerViewAttributesInfoNVX* = object
9502 sType*: VkStructureType
9503 pNext*: pointer
9504 perViewAttributes*: VkBool32
9505 perViewAttributesPositionXOnly*: VkBool32
9506 VkPhysicalDeviceImageViewMinLodFeaturesEXT* = object
9507 sType*: VkStructureType
9508 pNext*: pointer
9509 minLod*: VkBool32
9510 VkImageViewMinLodCreateInfoEXT* = object
9511 sType*: VkStructureType
9512 pNext*: pointer
9513 minLod*: float32
9514 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* = object
9515 sType*: VkStructureType
9516 pNext*: pointer
9517 rasterizationOrderColorAttachmentAccess*: VkBool32
9518 rasterizationOrderDepthAttachmentAccess*: VkBool32
9519 rasterizationOrderStencilAttachmentAccess*: VkBool32
9520 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM* = object
9521 VkPhysicalDeviceLinearColorAttachmentFeaturesNV* = object
9522 sType*: VkStructureType
9523 pNext*: pointer
9524 linearColorAttachment*: VkBool32
9525 VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* = object
9526 sType*: VkStructureType
9527 pNext*: pointer
9528 graphicsPipelineLibrary*: VkBool32
9529 VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* = object
9530 sType*: VkStructureType
9531 pNext*: pointer
9532 graphicsPipelineLibraryFastLinking*: VkBool32
9533 graphicsPipelineLibraryIndependentInterpolationDecoration*: VkBool32
9534 VkGraphicsPipelineLibraryCreateInfoEXT* = object
9535 sType*: VkStructureType
9536 pNext*: pointer
9537 flags*: VkGraphicsPipelineLibraryFlagsEXT
9538 VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* = object
9539 sType*: VkStructureType
9540 pNext*: pointer
9541 descriptorSetHostMapping*: VkBool32
9542 VkDescriptorSetBindingReferenceVALVE* = object
9543 sType*: VkStructureType
9544 pNext*: pointer
9545 descriptorSetLayout*: VkDescriptorSetLayout
9546 binding*: uint32
9547 VkDescriptorSetLayoutHostMappingInfoVALVE* = object
9548 sType*: VkStructureType
9549 pNext*: pointer
9550 descriptorOffset*: csize_t
9551 descriptorSize*: uint32
9552 VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* = object
9553 sType*: VkStructureType
9554 pNext*: pointer
9555 shaderModuleIdentifier*: VkBool32
9556 VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* = object
9557 sType*: VkStructureType
9558 pNext*: pointer
9559 shaderModuleIdentifierAlgorithmUUID*: array[VK_UUID_SIZE, uint8]
9560 VkPipelineShaderStageModuleIdentifierCreateInfoEXT* = object
9561 sType*: VkStructureType
9562 pNext*: pointer
9563 identifierSize*: uint32
9564 pIdentifier*: ptr uint8
9565 VkShaderModuleIdentifierEXT* = object
9566 sType*: VkStructureType
9567 pNext*: pointer
9568 identifierSize*: uint32
9569 identifier*: array[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT, uint8]
9570 VkImageCompressionControlEXT* = object
9571 sType*: VkStructureType
9572 pNext*: pointer
9573 flags*: VkImageCompressionFlagsEXT
9574 compressionControlPlaneCount*: uint32
9575 pFixedRateFlags*: ptr VkImageCompressionFixedRateFlagsEXT
9576 VkPhysicalDeviceImageCompressionControlFeaturesEXT* = object
9577 sType*: VkStructureType
9578 pNext*: pointer
9579 imageCompressionControl*: VkBool32
9580 VkImageCompressionPropertiesEXT* = object
9581 sType*: VkStructureType
9582 pNext*: pointer
9583 imageCompressionFlags*: VkImageCompressionFlagsEXT
9584 imageCompressionFixedRateFlags*: VkImageCompressionFixedRateFlagsEXT
9585 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* = object
9586 sType*: VkStructureType
9587 pNext*: pointer
9588 imageCompressionControlSwapchain*: VkBool32
9589 VkImageSubresource2EXT* = object
9590 sType*: VkStructureType
9591 pNext*: pointer
9592 imageSubresource*: VkImageSubresource
9593 VkSubresourceLayout2EXT* = object
9594 sType*: VkStructureType
9595 pNext*: pointer
9596 subresourceLayout*: VkSubresourceLayout
9597 VkRenderPassCreationControlEXT* = object
9598 sType*: VkStructureType
9599 pNext*: pointer
9600 disallowMerging*: VkBool32
9601 VkRenderPassCreationFeedbackInfoEXT* = object
9602 postMergeSubpassCount*: uint32
9603 VkRenderPassCreationFeedbackCreateInfoEXT* = object
9604 sType*: VkStructureType
9605 pNext*: pointer
9606 pRenderPassFeedback*: ptr VkRenderPassCreationFeedbackInfoEXT
9607 VkRenderPassSubpassFeedbackInfoEXT* = object
9608 subpassMergeStatus*: VkSubpassMergeStatusEXT
9609 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
9610 postMergeIndex*: uint32
9611 VkRenderPassSubpassFeedbackCreateInfoEXT* = object
9612 sType*: VkStructureType
9613 pNext*: pointer
9614 pSubpassFeedback*: ptr VkRenderPassSubpassFeedbackInfoEXT
9615 VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* = object
9616 sType*: VkStructureType
9617 pNext*: pointer
9618 subpassMergeFeedback*: VkBool32
9619 VkMicromapBuildInfoEXT* = object
9620 sType*: VkStructureType
9621 pNext*: pointer
9622 thetype*: VkMicromapTypeEXT
9623 flags*: VkBuildMicromapFlagsEXT
9624 mode*: VkBuildMicromapModeEXT
9625 dstMicromap*: VkMicromapEXT
9626 usageCountsCount*: uint32
9627 pUsageCounts*: ptr VkMicromapUsageEXT
9628 ppUsageCounts*: ptr ptr VkMicromapUsageEXT
9629 data*: VkDeviceOrHostAddressConstKHR
9630 scratchData*: VkDeviceOrHostAddressKHR
9631 triangleArray*: VkDeviceOrHostAddressConstKHR
9632 triangleArrayStride*: VkDeviceSize
9633 VkMicromapCreateInfoEXT* = object
9634 sType*: VkStructureType
9635 pNext*: pointer
9636 createFlags*: VkMicromapCreateFlagsEXT
9637 buffer*: VkBuffer
9638 offset*: VkDeviceSize
9639 size*: VkDeviceSize
9640 thetype*: VkMicromapTypeEXT
9641 deviceAddress*: VkDeviceAddress
9642 VkMicromapVersionInfoEXT* = object
9643 sType*: VkStructureType
9644 pNext*: pointer
9645 pVersionData*: ptr uint8
9646 VkCopyMicromapInfoEXT* = object
9647 sType*: VkStructureType
9648 pNext*: pointer
9649 src*: VkMicromapEXT
9650 dst*: VkMicromapEXT
9651 mode*: VkCopyMicromapModeEXT
9652 VkCopyMicromapToMemoryInfoEXT* = object
9653 sType*: VkStructureType
9654 pNext*: pointer
9655 src*: VkMicromapEXT
9656 dst*: VkDeviceOrHostAddressKHR
9657 mode*: VkCopyMicromapModeEXT
9658 VkCopyMemoryToMicromapInfoEXT* = object
9659 sType*: VkStructureType
9660 pNext*: pointer
9661 src*: VkDeviceOrHostAddressConstKHR
9662 dst*: VkMicromapEXT
9663 mode*: VkCopyMicromapModeEXT
9664 VkMicromapBuildSizesInfoEXT* = object
9665 sType*: VkStructureType
9666 pNext*: pointer
9667 micromapSize*: VkDeviceSize
9668 buildScratchSize*: VkDeviceSize
9669 discardable*: VkBool32
9670 VkMicromapUsageEXT* = object
9671 count*: uint32
9672 subdivisionLevel*: uint32
9673 format*: uint32
9674 VkMicromapTriangleEXT* = object
9675 dataOffset*: uint32
9676 subdivisionLevel*: uint16
9677 format*: uint16
9678 VkPhysicalDeviceOpacityMicromapFeaturesEXT* = object
9679 sType*: VkStructureType
9680 pNext*: pointer
9681 micromap*: VkBool32
9682 micromapCaptureReplay*: VkBool32
9683 micromapHostCommands*: VkBool32
9684 VkPhysicalDeviceOpacityMicromapPropertiesEXT* = object
9685 sType*: VkStructureType
9686 pNext*: pointer
9687 maxOpacity2StateSubdivisionLevel*: uint32
9688 maxOpacity4StateSubdivisionLevel*: uint32
9689 VkAccelerationStructureTrianglesOpacityMicromapEXT* = object
9690 sType*: VkStructureType
9691 pNext*: pointer
9692 indexType*: VkIndexType
9693 indexBuffer*: VkDeviceOrHostAddressConstKHR
9694 indexStride*: VkDeviceSize
9695 baseTriangle*: uint32
9696 usageCountsCount*: uint32
9697 pUsageCounts*: ptr VkMicromapUsageEXT
9698 ppUsageCounts*: ptr ptr VkMicromapUsageEXT
9699 micromap*: VkMicromapEXT
9700 VkPipelinePropertiesIdentifierEXT* = object
9701 sType*: VkStructureType
9702 pNext*: pointer
9703 pipelineIdentifier*: array[VK_UUID_SIZE, uint8]
9704 VkPhysicalDevicePipelinePropertiesFeaturesEXT* = object
9705 sType*: VkStructureType
9706 pNext*: pointer
9707 pipelinePropertiesIdentifier*: VkBool32
9708 VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* = object
9709 sType*: VkStructureType
9710 pNext*: pointer
9711 shaderEarlyAndLateFragmentTests*: VkBool32
9712 VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* = object
9713 sType*: VkStructureType
9714 pNext*: pointer
9715 nonSeamlessCubeMap*: VkBool32
9716 VkPhysicalDevicePipelineRobustnessFeaturesEXT* = object
9717 sType*: VkStructureType
9718 pNext*: pointer
9719 pipelineRobustness*: VkBool32
9720 VkPipelineRobustnessCreateInfoEXT* = object
9721 sType*: VkStructureType
9722 pNext*: pointer
9723 storageBuffers*: VkPipelineRobustnessBufferBehaviorEXT
9724 uniformBuffers*: VkPipelineRobustnessBufferBehaviorEXT
9725 vertexInputs*: VkPipelineRobustnessBufferBehaviorEXT
9726 images*: VkPipelineRobustnessImageBehaviorEXT
9727 VkPhysicalDevicePipelineRobustnessPropertiesEXT* = object
9728 sType*: VkStructureType
9729 pNext*: pointer
9730 defaultRobustnessStorageBuffers*: VkPipelineRobustnessBufferBehaviorEXT
9731 defaultRobustnessUniformBuffers*: VkPipelineRobustnessBufferBehaviorEXT
9732 defaultRobustnessVertexInputs*: VkPipelineRobustnessBufferBehaviorEXT
9733 defaultRobustnessImages*: VkPipelineRobustnessImageBehaviorEXT
9734 VkImageViewSampleWeightCreateInfoQCOM* = object
9735 sType*: VkStructureType
9736 pNext*: pointer
9737 filterCenter*: VkOffset2D
9738 filterSize*: VkExtent2D
9739 numPhases*: uint32
9740 VkPhysicalDeviceImageProcessingFeaturesQCOM* = object
9741 sType*: VkStructureType
9742 pNext*: pointer
9743 textureSampleWeighted*: VkBool32
9744 textureBoxFilter*: VkBool32
9745 textureBlockMatch*: VkBool32
9746 VkPhysicalDeviceImageProcessingPropertiesQCOM* = object
9747 sType*: VkStructureType
9748 pNext*: pointer
9749 maxWeightFilterPhases*: uint32
9750 maxWeightFilterDimension*: VkExtent2D
9751 maxBlockMatchRegion*: VkExtent2D
9752 maxBoxFilterBlockSize*: VkExtent2D
9753 VkPhysicalDeviceTilePropertiesFeaturesQCOM* = object
9754 sType*: VkStructureType
9755 pNext*: pointer
9756 tileProperties*: VkBool32
9757 VkTilePropertiesQCOM* = object
9758 sType*: VkStructureType
9759 pNext*: pointer
9760 tileSize*: VkExtent3D
9761 apronSize*: VkExtent2D
9762 origin*: VkOffset2D
9763 VkPhysicalDeviceAmigoProfilingFeaturesSEC* = object
9764 sType*: VkStructureType
9765 pNext*: pointer
9766 amigoProfiling*: VkBool32
9767 VkAmigoProfilingSubmitInfoSEC* = object
9768 sType*: VkStructureType
9769 pNext*: pointer
9770 firstDrawTimestamp*: uint64
9771 swapBufferTimestamp*: uint64
9772 VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* = object
9773 sType*: VkStructureType
9774 pNext*: pointer
9775 attachmentFeedbackLoopLayout*: VkBool32
9776 VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* = object
9777 sType*: VkStructureType
9778 pNext*: pointer
9779 depthClampZeroOne*: VkBool32
9780 VkPhysicalDeviceAddressBindingReportFeaturesEXT* = object
9781 sType*: VkStructureType
9782 pNext*: pointer
9783 reportAddressBinding*: VkBool32
9784 VkDeviceAddressBindingCallbackDataEXT* = object
9785 sType*: VkStructureType
9786 pNext*: pointer
9787 flags*: VkDeviceAddressBindingFlagsEXT
9788 baseAddress*: VkDeviceAddress
9789 size*: VkDeviceSize
9790 bindingType*: VkDeviceAddressBindingTypeEXT
9791 VkPhysicalDeviceOpticalFlowFeaturesNV* = object
9792 sType*: VkStructureType
9793 pNext*: pointer
9794 opticalFlow*: VkBool32
9795 VkPhysicalDeviceOpticalFlowPropertiesNV* = object
9796 sType*: VkStructureType
9797 pNext*: pointer
9798 supportedOutputGridSizes*: VkOpticalFlowGridSizeFlagsNV
9799 supportedHintGridSizes*: VkOpticalFlowGridSizeFlagsNV
9800 hintSupported*: VkBool32
9801 costSupported*: VkBool32
9802 bidirectionalFlowSupported*: VkBool32
9803 globalFlowSupported*: VkBool32
9804 minWidth*: uint32
9805 minHeight*: uint32
9806 maxWidth*: uint32
9807 maxHeight*: uint32
9808 maxNumRegionsOfInterest*: uint32
9809 VkOpticalFlowImageFormatInfoNV* = object
9810 sType*: VkStructureType
9811 pNext*: pointer
9812 usage*: VkOpticalFlowUsageFlagsNV
9813 VkOpticalFlowImageFormatPropertiesNV* = object
9814 sType*: VkStructureType
9815 pNext*: pointer
9816 format*: VkFormat
9817 VkOpticalFlowSessionCreateInfoNV* = object
9818 sType*: VkStructureType
9819 pNext*: pointer
9820 width*: uint32
9821 height*: uint32
9822 imageFormat*: VkFormat
9823 flowVectorFormat*: VkFormat
9824 costFormat*: VkFormat
9825 outputGridSize*: VkOpticalFlowGridSizeFlagsNV
9826 hintGridSize*: VkOpticalFlowGridSizeFlagsNV
9827 performanceLevel*: VkOpticalFlowPerformanceLevelNV
9828 flags*: VkOpticalFlowSessionCreateFlagsNV
9829 VkOpticalFlowSessionCreatePrivateDataInfoNV* = object
9830 sType*: VkStructureType
9831 pNext*: pointer
9832 id*: uint32
9833 size*: uint32
9834 pPrivateData*: pointer
9835 VkOpticalFlowExecuteInfoNV* = object
9836 sType*: VkStructureType
9837 pNext*: pointer
9838 flags*: VkOpticalFlowExecuteFlagsNV
9839 regionCount*: uint32
9840 pRegions*: ptr VkRect2D
9841 VkPhysicalDeviceFaultFeaturesEXT* = object
9842 sType*: VkStructureType
9843 pNext*: pointer
9844 deviceFault*: VkBool32
9845 deviceFaultVendorBinary*: VkBool32
9846 VkDeviceFaultAddressInfoEXT* = object
9847 addressType*: VkDeviceFaultAddressTypeEXT
9848 reportedAddress*: VkDeviceAddress
9849 addressPrecision*: VkDeviceSize
9850 VkDeviceFaultVendorInfoEXT* = object
9851 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
9852 vendorFaultCode*: uint64
9853 vendorFaultData*: uint64
9854 VkDeviceFaultCountsEXT* = object
9855 sType*: VkStructureType
9856 pNext*: pointer
9857 addressInfoCount*: uint32
9858 vendorInfoCount*: uint32
9859 vendorBinarySize*: VkDeviceSize
9860 VkDeviceFaultInfoEXT* = object
9861 sType*: VkStructureType
9862 pNext*: pointer
9863 description*: array[VK_MAX_DESCRIPTION_SIZE, char]
9864 pAddressInfos*: ptr VkDeviceFaultAddressInfoEXT
9865 pVendorInfos*: ptr VkDeviceFaultVendorInfoEXT
9866 pVendorBinaryData*: pointer
9867 VkDeviceFaultVendorBinaryHeaderVersionOneEXT* = object
9868 headerSize*: uint32
9869 headerVersion*: VkDeviceFaultVendorBinaryHeaderVersionEXT
9870 vendorID*: uint32
9871 deviceID*: uint32
9872 driverVersion*: uint32
9873 pipelineCacheUUID*: array[VK_UUID_SIZE, uint8]
9874 applicationNameOffset*: uint32
9875 applicationVersion*: uint32
9876 engineNameOffset*: uint32
9877 VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* = object
9878 sType*: VkStructureType
9879 pNext*: pointer
9880 pipelineLibraryGroupHandles*: VkBool32
9881 VkDecompressMemoryRegionNV* = object
9882 srcAddress*: VkDeviceAddress
9883 dstAddress*: VkDeviceAddress
9884 compressedSize*: VkDeviceSize
9885 decompressedSize*: VkDeviceSize
9886 decompressionMethod*: VkMemoryDecompressionMethodFlagsNV
9887 VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* = object
9888 sType*: VkStructureType
9889 pNext*: pointer
9890 shaderCoreMask*: uint64
9891 shaderCoreCount*: uint32
9892 shaderWarpsPerCore*: uint32
9893 VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* = object
9894 sType*: VkStructureType
9895 pNext*: pointer
9896 shaderCoreBuiltins*: VkBool32
9897 VkSurfacePresentModeEXT* = object
9898 sType*: VkStructureType
9899 pNext*: pointer
9900 presentMode*: VkPresentModeKHR
9901 VkSurfacePresentScalingCapabilitiesEXT* = object
9902 sType*: VkStructureType
9903 pNext*: pointer
9904 supportedPresentScaling*: VkPresentScalingFlagsEXT
9905 supportedPresentGravityX*: VkPresentGravityFlagsEXT
9906 supportedPresentGravityY*: VkPresentGravityFlagsEXT
9907 minScaledImageExtent*: VkExtent2D
9908 maxScaledImageExtent*: VkExtent2D
9909 VkSurfacePresentModeCompatibilityEXT* = object
9910 sType*: VkStructureType
9911 pNext*: pointer
9912 presentModeCount*: uint32
9913 pPresentModes*: ptr VkPresentModeKHR
9914 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* = object
9915 sType*: VkStructureType
9916 pNext*: pointer
9917 swapchainMaintenance1*: VkBool32
9918 VkSwapchainPresentFenceInfoEXT* = object
9919 sType*: VkStructureType
9920 pNext*: pointer
9921 swapchainCount*: uint32
9922 pFences*: ptr VkFence
9923 VkSwapchainPresentModesCreateInfoEXT* = object
9924 sType*: VkStructureType
9925 pNext*: pointer
9926 presentModeCount*: uint32
9927 pPresentModes*: ptr VkPresentModeKHR
9928 VkSwapchainPresentModeInfoEXT* = object
9929 sType*: VkStructureType
9930 pNext*: pointer
9931 swapchainCount*: uint32
9932 pPresentModes*: ptr VkPresentModeKHR
9933 VkSwapchainPresentScalingCreateInfoEXT* = object
9934 sType*: VkStructureType
9935 pNext*: pointer
9936 scalingBehavior*: VkPresentScalingFlagsEXT
9937 presentGravityX*: VkPresentGravityFlagsEXT
9938 presentGravityY*: VkPresentGravityFlagsEXT
9939 VkReleaseSwapchainImagesInfoEXT* = object
9940 sType*: VkStructureType
9941 pNext*: pointer
9942 swapchain*: VkSwapchainKHR
9943 imageIndexCount*: uint32
9944 pImageIndices*: ptr uint32
9945 VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* = object
9946 sType*: VkStructureType
9947 pNext*: pointer
9948 rayTracingInvocationReorder*: VkBool32
9949 VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* = object
9950 sType*: VkStructureType
9951 pNext*: pointer
9952 rayTracingInvocationReorderReorderingHint*: VkRayTracingInvocationReorderModeNV
9953 VkDirectDriverLoadingInfoLUNARG* = object
9954 sType*: VkStructureType
9955 pNext*: pointer
9956 flags*: VkDirectDriverLoadingFlagsLUNARG
9957 pfnGetInstanceProcAddr*: PFN_vkGetInstanceProcAddrLUNARG
9958 VkDirectDriverLoadingListLUNARG* = object
9959 sType*: VkStructureType
9960 pNext*: pointer
9961 mode*: VkDirectDriverLoadingModeLUNARG
9962 driverCount*: uint32
9963 pDrivers*: ptr VkDirectDriverLoadingInfoLUNARG
9964 VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* = object
9965 sType*: VkStructureType
9966 pNext*: pointer
9967 multiviewPerViewViewports*: VkBool32
9968 VkPhysicalDeviceShaderCorePropertiesARM* = object
9969 sType*: VkStructureType
9970 pNext*: pointer
9971 pixelRate*: uint32
9972 texelRate*: uint32
9973 fmaRate*: uint32
9974 VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* = object
9975 sType*: VkStructureType
9976 pNext*: pointer
9977 multiviewPerViewRenderAreas*: VkBool32
9978 VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* = object
9979 sType*: VkStructureType
9980 pNext*: pointer
9981 perViewRenderAreaCount*: uint32
9982 pPerViewRenderAreas*: ptr VkRect2D
9983 # feature VK_VERSION_1_0
9984 var
9985 vkCreateInstance*: proc(pCreateInfo: ptr VkInstanceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pInstance: ptr VkInstance): VkResult {.stdcall.}
9986 vkDestroyInstance*: proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
9987 vkEnumeratePhysicalDevices*: proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32, pPhysicalDevices: ptr VkPhysicalDevice): VkResult {.stdcall.}
9988 vkGetPhysicalDeviceFeatures*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures): void {.stdcall.}
9989 vkGetPhysicalDeviceFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties): void {.stdcall.}
9990 vkGetPhysicalDeviceImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties): VkResult {.stdcall.}
9991 vkGetPhysicalDeviceProperties*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties): void {.stdcall.}
9992 vkGetPhysicalDeviceQueueFamilyProperties*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties): void {.stdcall.}
9993 vkGetPhysicalDeviceMemoryProperties*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties): void {.stdcall.}
9994 vkGetDeviceProcAddr*: proc(device: VkDevice, pName: cstring): PFN_vkVoidFunction {.stdcall.}
9995 vkCreateDevice*: proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDevice: ptr VkDevice): VkResult {.stdcall.}
9996 vkDestroyDevice*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
9997 vkEnumerateInstanceExtensionProperties*: proc(pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}
9998 vkEnumerateDeviceExtensionProperties*: proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}
9999 vkEnumerateInstanceLayerProperties*: proc(pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}
10000 vkEnumerateDeviceLayerProperties*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}
10001 vkGetDeviceQueue*: proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue): void {.stdcall.}
10002 vkQueueSubmit*: proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo, fence: VkFence): VkResult {.stdcall.}
10003 vkQueueWaitIdle*: proc(queue: VkQueue): VkResult {.stdcall.}
10004 vkDeviceWaitIdle*: proc(device: VkDevice): VkResult {.stdcall.}
10005 vkAllocateMemory*: proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo, pAllocator: ptr VkAllocationCallbacks, pMemory: ptr VkDeviceMemory): VkResult {.stdcall.}
10006 vkFreeMemory*: proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10007 vkMapMemory*: proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer): VkResult {.stdcall.}
10008 vkUnmapMemory*: proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}
10009 vkFlushMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.}
10010 vkInvalidateMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.}
10011 vkGetDeviceMemoryCommitment*: proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize): void {.stdcall.}
10012 vkBindBufferMemory*: proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}
10013 vkBindImageMemory*: proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}
10014 vkGetBufferMemoryRequirements*: proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.}
10015 vkGetImageMemoryRequirements*: proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.}
10016 vkGetImageSparseMemoryRequirements*: proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements): void {.stdcall.}
10017 vkGetPhysicalDeviceSparseImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties): void {.stdcall.}
10018 vkQueueBindSparse*: proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo, fence: VkFence): VkResult {.stdcall.}
10019 vkCreateFence*: proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}
10020 vkDestroyFence*: proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10021 vkResetFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence): VkResult {.stdcall.}
10022 vkGetFenceStatus*: proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}
10023 vkWaitForFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence, waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}
10024 vkCreateSemaphore*: proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSemaphore: ptr VkSemaphore): VkResult {.stdcall.}
10025 vkDestroySemaphore*: proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10026 vkCreateEvent*: proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo, pAllocator: ptr VkAllocationCallbacks, pEvent: ptr VkEvent): VkResult {.stdcall.}
10027 vkDestroyEvent*: proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10028 vkGetEventStatus*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
10029 vkSetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
10030 vkResetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
10031 vkCreateQueryPool*: proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pQueryPool: ptr VkQueryPool): VkResult {.stdcall.}
10032 vkDestroyQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10033 vkGetQueryPoolResults*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: csize_t, pData: pointer, stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.}
10034 vkCreateBuffer*: proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pBuffer: ptr VkBuffer): VkResult {.stdcall.}
10035 vkDestroyBuffer*: proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10036 vkCreateBufferView*: proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkBufferView): VkResult {.stdcall.}
10037 vkDestroyBufferView*: proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10038 vkCreateImage*: proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo, pAllocator: ptr VkAllocationCallbacks, pImage: ptr VkImage): VkResult {.stdcall.}
10039 vkDestroyImage*: proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10040 vkGetImageSubresourceLayout*: proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource, pLayout: ptr VkSubresourceLayout): void {.stdcall.}
10041 vkCreateImageView*: proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkImageView): VkResult {.stdcall.}
10042 vkDestroyImageView*: proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10043 vkCreateShaderModule*: proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pAllocator: ptr VkAllocationCallbacks, pShaderModule: ptr VkShaderModule): VkResult {.stdcall.}
10044 vkDestroyShaderModule*: proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10045 vkCreatePipelineCache*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineCache: ptr VkPipelineCache): VkResult {.stdcall.}
10046 vkDestroyPipelineCache*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10047 vkGetPipelineCacheData*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.}
10048 vkMergePipelineCaches*: proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache): VkResult {.stdcall.}
10049 vkCreateGraphicsPipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}
10050 vkCreateComputePipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}
10051 vkDestroyPipeline*: proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10052 vkCreatePipelineLayout*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineLayout: ptr VkPipelineLayout): VkResult {.stdcall.}
10053 vkDestroyPipelineLayout*: proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10054 vkCreateSampler*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSampler: ptr VkSampler): VkResult {.stdcall.}
10055 vkDestroySampler*: proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10056 vkCreateDescriptorSetLayout*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSetLayout: ptr VkDescriptorSetLayout): VkResult {.stdcall.}
10057 vkDestroyDescriptorSetLayout*: proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10058 vkCreateDescriptorPool*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorPool: ptr VkDescriptorPool): VkResult {.stdcall.}
10059 vkDestroyDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10060 vkResetDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}
10061 vkAllocateDescriptorSets*: proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.}
10062 vkFreeDescriptorSets*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.}
10063 vkUpdateDescriptorSets*: proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet, descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet): void {.stdcall.}
10064 vkCreateFramebuffer*: proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFramebuffer: ptr VkFramebuffer): VkResult {.stdcall.}
10065 vkDestroyFramebuffer*: proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10066 vkCreateRenderPass*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.}
10067 vkDestroyRenderPass*: proc(device: VkDevice, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10068 vkGetRenderAreaGranularity*: proc(device: VkDevice, renderPass: VkRenderPass, pGranularity: ptr VkExtent2D): void {.stdcall.}
10069 vkCreateCommandPool*: proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pCommandPool: ptr VkCommandPool): VkResult {.stdcall.}
10070 vkDestroyCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10071 vkResetCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}
10072 vkAllocateCommandBuffers*: proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo, pCommandBuffers: ptr VkCommandBuffer): VkResult {.stdcall.}
10073 vkFreeCommandBuffers*: proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.}
10074 vkBeginCommandBuffer*: proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo): VkResult {.stdcall.}
10075 vkEndCommandBuffer*: proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}
10076 vkResetCommandBuffer*: proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}
10077 vkCmdBindPipeline*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}
10078 vkCmdSetViewport*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.}
10079 vkCmdSetScissor*: proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.}
10080 vkCmdSetLineWidth*: proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}
10081 vkCmdSetDepthBias*: proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}
10082 vkCmdSetBlendConstants*: proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}
10083 vkCmdSetDepthBounds*: proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}
10084 vkCmdSetStencilCompareMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}
10085 vkCmdSetStencilWriteMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}
10086 vkCmdSetStencilReference*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}
10087 vkCmdBindDescriptorSets*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet, dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32): void {.stdcall.}
10088 vkCmdBindIndexBuffer*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}
10089 vkCmdBindVertexBuffers*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize): void {.stdcall.}
10090 vkCmdDraw*: proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}
10091 vkCmdDrawIndexed*: proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}
10092 vkCmdDrawIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
10093 vkCmdDrawIndexedIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
10094 vkCmdDispatch*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
10095 vkCmdDispatchIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}
10096 vkCmdCopyBuffer*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy): void {.stdcall.}
10097 vkCmdCopyImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy): void {.stdcall.}
10098 vkCmdBlitImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit, filter: VkFilter): void {.stdcall.}
10099 vkCmdCopyBufferToImage*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.}
10100 vkCmdCopyImageToBuffer*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.}
10101 vkCmdUpdateBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer): void {.stdcall.}
10102 vkCmdFillBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}
10103 vkCmdClearColorImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.}
10104 vkCmdClearDepthStencilImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.}
10105 vkCmdClearAttachments*: proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment, rectCount: uint32, pRects: ptr VkClearRect): void {.stdcall.}
10106 vkCmdResolveImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve): void {.stdcall.}
10107 vkCmdSetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}
10108 vkCmdResetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}
10109 vkCmdWaitEvents*: proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier, bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier): void {.stdcall.}
10110 vkCmdPipelineBarrier*: proc(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier, bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier): void {.stdcall.}
10111 vkCmdBeginQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}
10112 vkCmdEndQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
10113 vkCmdResetQueryPool*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}
10114 vkCmdWriteTimestamp*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
10115 vkCmdCopyQueryPoolResults*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}
10116 vkCmdPushConstants*: proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer): void {.stdcall.}
10117 vkCmdBeginRenderPass*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, contents: VkSubpassContents): void {.stdcall.}
10118 vkCmdNextSubpass*: proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}
10119 vkCmdEndRenderPass*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
10120 vkCmdExecuteCommands*: proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.}
10121 proc loadVK_VERSION_1_0*(instance: VkInstance) =
10122 vkDestroyInstance = cast[proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyInstance"))
10123 vkEnumeratePhysicalDevices = cast[proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32, pPhysicalDevices: ptr VkPhysicalDevice): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices"))
10124 vkGetPhysicalDeviceFeatures = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures"))
10125 vkGetPhysicalDeviceFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties"))
10126 vkGetPhysicalDeviceImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties"))
10127 vkGetPhysicalDeviceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties"))
10128 vkGetPhysicalDeviceQueueFamilyProperties = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"))
10129 vkGetPhysicalDeviceMemoryProperties = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties"))
10130 vkGetDeviceProcAddr = cast[proc(device: VkDevice, pName: cstring): PFN_vkVoidFunction {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr"))
10131 vkCreateDevice = cast[proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDevice: ptr VkDevice): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDevice"))
10132 vkDestroyDevice = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDevice"))
10133 vkEnumerateDeviceExtensionProperties = cast[proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties"))
10134 vkEnumerateDeviceLayerProperties = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties"))
10135 vkGetDeviceQueue = cast[proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceQueue"))
10136 vkQueueSubmit = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueSubmit"))
10137 vkQueueWaitIdle = cast[proc(queue: VkQueue): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueWaitIdle"))
10138 vkDeviceWaitIdle = cast[proc(device: VkDevice): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDeviceWaitIdle"))
10139 vkAllocateMemory = cast[proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo, pAllocator: ptr VkAllocationCallbacks, pMemory: ptr VkDeviceMemory): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAllocateMemory"))
10140 vkFreeMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFreeMemory"))
10141 vkMapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkMapMemory"))
10142 vkUnmapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUnmapMemory"))
10143 vkFlushMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges"))
10144 vkInvalidateMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges"))
10145 vkGetDeviceMemoryCommitment = cast[proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment"))
10146 vkBindBufferMemory = cast[proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindBufferMemory"))
10147 vkBindImageMemory = cast[proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindImageMemory"))
10148 vkGetBufferMemoryRequirements = cast[proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements"))
10149 vkGetImageMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements"))
10150 vkGetImageSparseMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements"))
10151 vkGetPhysicalDeviceSparseImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"))
10152 vkQueueBindSparse = cast[proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueBindSparse"))
10153 vkCreateFence = cast[proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateFence"))
10154 vkDestroyFence = cast[proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyFence"))
10155 vkResetFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetFences"))
10156 vkGetFenceStatus = cast[proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetFenceStatus"))
10157 vkWaitForFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence, waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWaitForFences"))
10158 vkCreateSemaphore = cast[proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSemaphore: ptr VkSemaphore): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSemaphore"))
10159 vkDestroySemaphore = cast[proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySemaphore"))
10160 vkCreateEvent = cast[proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo, pAllocator: ptr VkAllocationCallbacks, pEvent: ptr VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateEvent"))
10161 vkDestroyEvent = cast[proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyEvent"))
10162 vkGetEventStatus = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetEventStatus"))
10163 vkSetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetEvent"))
10164 vkResetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetEvent"))
10165 vkCreateQueryPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pQueryPool: ptr VkQueryPool): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateQueryPool"))
10166 vkDestroyQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyQueryPool"))
10167 vkGetQueryPoolResults = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: csize_t, pData: pointer, stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetQueryPoolResults"))
10168 vkCreateBuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pBuffer: ptr VkBuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateBuffer"))
10169 vkDestroyBuffer = cast[proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyBuffer"))
10170 vkCreateBufferView = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkBufferView): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateBufferView"))
10171 vkDestroyBufferView = cast[proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyBufferView"))
10172 vkCreateImage = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo, pAllocator: ptr VkAllocationCallbacks, pImage: ptr VkImage): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateImage"))
10173 vkDestroyImage = cast[proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyImage"))
10174 vkGetImageSubresourceLayout = cast[proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource, pLayout: ptr VkSubresourceLayout): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout"))
10175 vkCreateImageView = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkImageView): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateImageView"))
10176 vkDestroyImageView = cast[proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyImageView"))
10177 vkCreateShaderModule = cast[proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pAllocator: ptr VkAllocationCallbacks, pShaderModule: ptr VkShaderModule): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateShaderModule"))
10178 vkDestroyShaderModule = cast[proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyShaderModule"))
10179 vkCreatePipelineCache = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineCache: ptr VkPipelineCache): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreatePipelineCache"))
10180 vkDestroyPipelineCache = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPipelineCache"))
10181 vkGetPipelineCacheData = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineCacheData"))
10182 vkMergePipelineCaches = cast[proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkMergePipelineCaches"))
10183 vkCreateGraphicsPipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateGraphicsPipelines"))
10184 vkCreateComputePipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateComputePipelines"))
10185 vkDestroyPipeline = cast[proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPipeline"))
10186 vkCreatePipelineLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineLayout: ptr VkPipelineLayout): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreatePipelineLayout"))
10187 vkDestroyPipelineLayout = cast[proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPipelineLayout"))
10188 vkCreateSampler = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSampler: ptr VkSampler): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSampler"))
10189 vkDestroySampler = cast[proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySampler"))
10190 vkCreateDescriptorSetLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSetLayout: ptr VkDescriptorSetLayout): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout"))
10191 vkDestroyDescriptorSetLayout = cast[proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout"))
10192 vkCreateDescriptorPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorPool: ptr VkDescriptorPool): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDescriptorPool"))
10193 vkDestroyDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDescriptorPool"))
10194 vkResetDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetDescriptorPool"))
10195 vkAllocateDescriptorSets = cast[proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAllocateDescriptorSets"))
10196 vkFreeDescriptorSets = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFreeDescriptorSets"))
10197 vkUpdateDescriptorSets = cast[proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet, descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSets"))
10198 vkCreateFramebuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFramebuffer: ptr VkFramebuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateFramebuffer"))
10199 vkDestroyFramebuffer = cast[proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyFramebuffer"))
10200 vkCreateRenderPass = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRenderPass"))
10201 vkDestroyRenderPass = cast[proc(device: VkDevice, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyRenderPass"))
10202 vkGetRenderAreaGranularity = cast[proc(device: VkDevice, renderPass: VkRenderPass, pGranularity: ptr VkExtent2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRenderAreaGranularity"))
10203 vkCreateCommandPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pCommandPool: ptr VkCommandPool): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateCommandPool"))
10204 vkDestroyCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyCommandPool"))
10205 vkResetCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetCommandPool"))
10206 vkAllocateCommandBuffers = cast[proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo, pCommandBuffers: ptr VkCommandBuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAllocateCommandBuffers"))
10207 vkFreeCommandBuffers = cast[proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFreeCommandBuffers"))
10208 vkBeginCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBeginCommandBuffer"))
10209 vkEndCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEndCommandBuffer"))
10210 vkResetCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetCommandBuffer"))
10211 vkCmdBindPipeline = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindPipeline"))
10212 vkCmdSetViewport = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewport"))
10213 vkCmdSetScissor = cast[proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetScissor"))
10214 vkCmdSetLineWidth = cast[proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineWidth"))
10215 vkCmdSetDepthBias = cast[proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBias"))
10216 vkCmdSetBlendConstants = cast[proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetBlendConstants"))
10217 vkCmdSetDepthBounds = cast[proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBounds"))
10218 vkCmdSetStencilCompareMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask"))
10219 vkCmdSetStencilWriteMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask"))
10220 vkCmdSetStencilReference = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilReference"))
10221 vkCmdBindDescriptorSets = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet, dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorSets"))
10222 vkCmdBindIndexBuffer = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindIndexBuffer"))
10223 vkCmdBindVertexBuffers = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers"))
10224 vkCmdDraw = cast[proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDraw"))
10225 vkCmdDrawIndexed = cast[proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndexed"))
10226 vkCmdDrawIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndirect"))
10227 vkCmdDrawIndexedIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect"))
10228 vkCmdDispatch = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDispatch"))
10229 vkCmdDispatchIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDispatchIndirect"))
10230 vkCmdCopyBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer"))
10231 vkCmdCopyImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImage"))
10232 vkCmdBlitImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit, filter: VkFilter): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBlitImage"))
10233 vkCmdCopyBufferToImage = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage"))
10234 vkCmdCopyImageToBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer"))
10235 vkCmdUpdateBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdUpdateBuffer"))
10236 vkCmdFillBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdFillBuffer"))
10237 vkCmdClearColorImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdClearColorImage"))
10238 vkCmdClearDepthStencilImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage"))
10239 vkCmdClearAttachments = cast[proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment, rectCount: uint32, pRects: ptr VkClearRect): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdClearAttachments"))
10240 vkCmdResolveImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResolveImage"))
10241 vkCmdSetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetEvent"))
10242 vkCmdResetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResetEvent"))
10243 vkCmdWaitEvents = cast[proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier, bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWaitEvents"))
10244 vkCmdPipelineBarrier = cast[proc(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier, bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier"))
10245 vkCmdBeginQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginQuery"))
10246 vkCmdEndQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndQuery"))
10247 vkCmdResetQueryPool = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResetQueryPool"))
10248 vkCmdWriteTimestamp = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp"))
10249 vkCmdCopyQueryPoolResults = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults"))
10250 vkCmdPushConstants = cast[proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushConstants"))
10251 vkCmdBeginRenderPass = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, contents: VkSubpassContents): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass"))
10252 vkCmdNextSubpass = cast[proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdNextSubpass"))
10253 vkCmdEndRenderPass = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass"))
10254 vkCmdExecuteCommands = cast[proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdExecuteCommands"))
10255
10256 # feature VK_VERSION_1_1
10257 var
10258 vkEnumerateInstanceVersion*: proc(pApiVersion: ptr uint32): VkResult {.stdcall.}
10259 vkBindBufferMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo): VkResult {.stdcall.}
10260 vkBindImageMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo): VkResult {.stdcall.}
10261 vkGetDeviceGroupPeerMemoryFeatures*: proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags): void {.stdcall.}
10262 vkCmdSetDeviceMask*: proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}
10263 vkCmdDispatchBase*: proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
10264 vkEnumeratePhysicalDeviceGroups*: proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32, pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties): VkResult {.stdcall.}
10265 vkGetImageMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}
10266 vkGetBufferMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}
10267 vkGetImageSparseMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.}
10268 vkGetPhysicalDeviceFeatures2*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2): void {.stdcall.}
10269 vkGetPhysicalDeviceProperties2*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2): void {.stdcall.}
10270 vkGetPhysicalDeviceFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2): void {.stdcall.}
10271 vkGetPhysicalDeviceImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: ptr VkImageFormatProperties2): VkResult {.stdcall.}
10272 vkGetPhysicalDeviceQueueFamilyProperties2*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties2): void {.stdcall.}
10273 vkGetPhysicalDeviceMemoryProperties2*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2): void {.stdcall.}
10274 vkGetPhysicalDeviceSparseImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties2): void {.stdcall.}
10275 vkTrimCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}
10276 vkGetDeviceQueue2*: proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2, pQueue: ptr VkQueue): void {.stdcall.}
10277 vkCreateSamplerYcbcrConversion*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo, pAllocator: ptr VkAllocationCallbacks, pYcbcrConversion: ptr VkSamplerYcbcrConversion): VkResult {.stdcall.}
10278 vkDestroySamplerYcbcrConversion*: proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10279 vkCreateDescriptorUpdateTemplate*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate): VkResult {.stdcall.}
10280 vkDestroyDescriptorUpdateTemplate*: proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10281 vkUpdateDescriptorSetWithTemplate*: proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer): void {.stdcall.}
10282 vkGetPhysicalDeviceExternalBufferProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ptr VkExternalBufferProperties): void {.stdcall.}
10283 vkGetPhysicalDeviceExternalFenceProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ptr VkExternalFenceProperties): void {.stdcall.}
10284 vkGetPhysicalDeviceExternalSemaphoreProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties): void {.stdcall.}
10285 vkGetDescriptorSetLayoutSupport*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pSupport: ptr VkDescriptorSetLayoutSupport): void {.stdcall.}
10286 proc loadVK_VERSION_1_1*(instance: VkInstance) =
10287 vkBindBufferMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindBufferMemory2"))
10288 vkBindImageMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindImageMemory2"))
10289 vkGetDeviceGroupPeerMemoryFeatures = cast[proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures"))
10290 vkCmdSetDeviceMask = cast[proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMask"))
10291 vkCmdDispatchBase = cast[proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDispatchBase"))
10292 vkEnumeratePhysicalDeviceGroups = cast[proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32, pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroups"))
10293 vkGetImageMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2"))
10294 vkGetBufferMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2"))
10295 vkGetImageSparseMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2"))
10296 vkGetPhysicalDeviceFeatures2 = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"))
10297 vkGetPhysicalDeviceProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"))
10298 vkGetPhysicalDeviceFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2"))
10299 vkGetPhysicalDeviceImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: ptr VkImageFormatProperties2): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2"))
10300 vkGetPhysicalDeviceQueueFamilyProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2"))
10301 vkGetPhysicalDeviceMemoryProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2"))
10302 vkGetPhysicalDeviceSparseImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
10303 vkTrimCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkTrimCommandPool"))
10304 vkGetDeviceQueue2 = cast[proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2, pQueue: ptr VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceQueue2"))
10305 vkCreateSamplerYcbcrConversion = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo, pAllocator: ptr VkAllocationCallbacks, pYcbcrConversion: ptr VkSamplerYcbcrConversion): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion"))
10306 vkDestroySamplerYcbcrConversion = cast[proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion"))
10307 vkCreateDescriptorUpdateTemplate = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate"))
10308 vkDestroyDescriptorUpdateTemplate = cast[proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate"))
10309 vkUpdateDescriptorSetWithTemplate = cast[proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate"))
10310 vkGetPhysicalDeviceExternalBufferProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ptr VkExternalBufferProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties"))
10311 vkGetPhysicalDeviceExternalFenceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ptr VkExternalFenceProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties"))
10312 vkGetPhysicalDeviceExternalSemaphoreProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
10313 vkGetDescriptorSetLayoutSupport = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pSupport: ptr VkDescriptorSetLayoutSupport): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport"))
10314
10315 # feature VK_VERSION_1_2
10316 var
10317 vkCmdDrawIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
10318 vkCmdDrawIndexedIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
10319 vkCreateRenderPass2*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.}
10320 vkCmdBeginRenderPass2*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, pSubpassBeginInfo: ptr VkSubpassBeginInfo): void {.stdcall.}
10321 vkCmdNextSubpass2*: proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.}
10322 vkCmdEndRenderPass2*: proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.}
10323 vkResetQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}
10324 vkGetSemaphoreCounterValue*: proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64): VkResult {.stdcall.}
10325 vkWaitSemaphores*: proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo, timeout: uint64): VkResult {.stdcall.}
10326 vkSignalSemaphore*: proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo): VkResult {.stdcall.}
10327 vkGetBufferDeviceAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): VkDeviceAddress {.stdcall.}
10328 vkGetBufferOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): uint64 {.stdcall.}
10329 vkGetDeviceMemoryOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo): uint64 {.stdcall.}
10330 proc loadVK_VERSION_1_2*(instance: VkInstance) =
10331 vkCmdDrawIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCount"))
10332 vkCmdDrawIndexedIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount"))
10333 vkCreateRenderPass2 = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRenderPass2"))
10334 vkCmdBeginRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, pSubpassBeginInfo: ptr VkSubpassBeginInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2"))
10335 vkCmdNextSubpass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2"))
10336 vkCmdEndRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2"))
10337 vkResetQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetQueryPool"))
10338 vkGetSemaphoreCounterValue = cast[proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue"))
10339 vkWaitSemaphores = cast[proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo, timeout: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWaitSemaphores"))
10340 vkSignalSemaphore = cast[proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSignalSemaphore"))
10341 vkGetBufferDeviceAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): VkDeviceAddress {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddress"))
10342 vkGetBufferOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): uint64 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress"))
10343 vkGetDeviceMemoryOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo): uint64 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddress"))
10344
10345 # feature VK_VERSION_1_3
10346 var
10347 vkGetPhysicalDeviceToolProperties*: proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32, pToolProperties: ptr VkPhysicalDeviceToolProperties): VkResult {.stdcall.}
10348 vkCreatePrivateDataSlot*: proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPrivateDataSlot: ptr VkPrivateDataSlot): VkResult {.stdcall.}
10349 vkDestroyPrivateDataSlot*: proc(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10350 vkSetPrivateData*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, data: uint64): VkResult {.stdcall.}
10351 vkGetPrivateData*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, pData: ptr uint64): void {.stdcall.}
10352 vkCmdSetEvent2*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.}
10353 vkCmdResetEvent2*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2): void {.stdcall.}
10354 vkCmdWaitEvents2*: proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent, pDependencyInfos: ptr VkDependencyInfo): void {.stdcall.}
10355 vkCmdPipelineBarrier2*: proc(commandBuffer: VkCommandBuffer, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.}
10356 vkCmdWriteTimestamp2*: proc(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
10357 vkQueueSubmit2*: proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo2, fence: VkFence): VkResult {.stdcall.}
10358 vkCmdCopyBuffer2*: proc(commandBuffer: VkCommandBuffer, pCopyBufferInfo: ptr VkCopyBufferInfo2): void {.stdcall.}
10359 vkCmdCopyImage2*: proc(commandBuffer: VkCommandBuffer, pCopyImageInfo: ptr VkCopyImageInfo2): void {.stdcall.}
10360 vkCmdCopyBufferToImage2*: proc(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: ptr VkCopyBufferToImageInfo2): void {.stdcall.}
10361 vkCmdCopyImageToBuffer2*: proc(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: ptr VkCopyImageToBufferInfo2): void {.stdcall.}
10362 vkCmdBlitImage2*: proc(commandBuffer: VkCommandBuffer, pBlitImageInfo: ptr VkBlitImageInfo2): void {.stdcall.}
10363 vkCmdResolveImage2*: proc(commandBuffer: VkCommandBuffer, pResolveImageInfo: ptr VkResolveImageInfo2): void {.stdcall.}
10364 vkCmdBeginRendering*: proc(commandBuffer: VkCommandBuffer, pRenderingInfo: ptr VkRenderingInfo): void {.stdcall.}
10365 vkCmdEndRendering*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
10366 vkCmdSetCullMode*: proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}
10367 vkCmdSetFrontFace*: proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}
10368 vkCmdSetPrimitiveTopology*: proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}
10369 vkCmdSetViewportWithCount*: proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.}
10370 vkCmdSetScissorWithCount*: proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.}
10371 vkCmdBindVertexBuffers2*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize, pStrides: ptr VkDeviceSize): void {.stdcall.}
10372 vkCmdSetDepthTestEnable*: proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}
10373 vkCmdSetDepthWriteEnable*: proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}
10374 vkCmdSetDepthCompareOp*: proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}
10375 vkCmdSetDepthBoundsTestEnable*: proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}
10376 vkCmdSetStencilTestEnable*: proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}
10377 vkCmdSetStencilOp*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}
10378 vkCmdSetRasterizerDiscardEnable*: proc(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32): void {.stdcall.}
10379 vkCmdSetDepthBiasEnable*: proc(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32): void {.stdcall.}
10380 vkCmdSetPrimitiveRestartEnable*: proc(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32): void {.stdcall.}
10381 vkGetDeviceBufferMemoryRequirements*: proc(device: VkDevice, pInfo: ptr VkDeviceBufferMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}
10382 vkGetDeviceImageMemoryRequirements*: proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}
10383 vkGetDeviceImageSparseMemoryRequirements*: proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.}
10384 proc loadVK_VERSION_1_3*(instance: VkInstance) =
10385 vkGetPhysicalDeviceToolProperties = cast[proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32, pToolProperties: ptr VkPhysicalDeviceToolProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolProperties"))
10386 vkCreatePrivateDataSlot = cast[proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPrivateDataSlot: ptr VkPrivateDataSlot): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlot"))
10387 vkDestroyPrivateDataSlot = cast[proc(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPrivateDataSlot"))
10388 vkSetPrivateData = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, data: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetPrivateData"))
10389 vkGetPrivateData = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, pData: ptr uint64): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPrivateData"))
10390 vkCmdSetEvent2 = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetEvent2"))
10391 vkCmdResetEvent2 = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResetEvent2"))
10392 vkCmdWaitEvents2 = cast[proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent, pDependencyInfos: ptr VkDependencyInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2"))
10393 vkCmdPipelineBarrier2 = cast[proc(commandBuffer: VkCommandBuffer, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2"))
10394 vkCmdWriteTimestamp2 = cast[proc(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2"))
10395 vkQueueSubmit2 = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo2, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueSubmit2"))
10396 vkCmdCopyBuffer2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyBufferInfo: ptr VkCopyBufferInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2"))
10397 vkCmdCopyImage2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyImageInfo: ptr VkCopyImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImage2"))
10398 vkCmdCopyBufferToImage2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: ptr VkCopyBufferToImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2"))
10399 vkCmdCopyImageToBuffer2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: ptr VkCopyImageToBufferInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2"))
10400 vkCmdBlitImage2 = cast[proc(commandBuffer: VkCommandBuffer, pBlitImageInfo: ptr VkBlitImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBlitImage2"))
10401 vkCmdResolveImage2 = cast[proc(commandBuffer: VkCommandBuffer, pResolveImageInfo: ptr VkResolveImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResolveImage2"))
10402 vkCmdBeginRendering = cast[proc(commandBuffer: VkCommandBuffer, pRenderingInfo: ptr VkRenderingInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginRendering"))
10403 vkCmdEndRendering = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndRendering"))
10404 vkCmdSetCullMode = cast[proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCullMode"))
10405 vkCmdSetFrontFace = cast[proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetFrontFace"))
10406 vkCmdSetPrimitiveTopology = cast[proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopology"))
10407 vkCmdSetViewportWithCount = cast[proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportWithCount"))
10408 vkCmdSetScissorWithCount = cast[proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetScissorWithCount"))
10409 vkCmdBindVertexBuffers2 = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize, pStrides: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2"))
10410 vkCmdSetDepthTestEnable = cast[proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable"))
10411 vkCmdSetDepthWriteEnable = cast[proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnable"))
10412 vkCmdSetDepthCompareOp = cast[proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp"))
10413 vkCmdSetDepthBoundsTestEnable = cast[proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnable"))
10414 vkCmdSetStencilTestEnable = cast[proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilTestEnable"))
10415 vkCmdSetStencilOp = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilOp"))
10416 vkCmdSetRasterizerDiscardEnable = cast[proc(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnable"))
10417 vkCmdSetDepthBiasEnable = cast[proc(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable"))
10418 vkCmdSetPrimitiveRestartEnable = cast[proc(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnable"))
10419 vkGetDeviceBufferMemoryRequirements = cast[proc(device: VkDevice, pInfo: ptr VkDeviceBufferMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirements"))
10420 vkGetDeviceImageMemoryRequirements = cast[proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirements"))
10421 vkGetDeviceImageSparseMemoryRequirements = cast[proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirements"))
10422
10423
10424 proc loadVulkan*(instance: VkInstance) =
10425 loadVK_VERSION_1_0(instance)
10426 loadVK_VERSION_1_1(instance)
10427 loadVK_VERSION_1_2(instance)
10428 loadVK_VERSION_1_3(instance)
10429
10430 proc loadVK_NV_geometry_shader_passthrough*(instance: VkInstance) =
10431 discard
10432
10433 proc loadVK_EXT_rasterization_order_attachment_access*(instance: VkInstance) =
10434 loadVK_VERSION_1_1(instance)
10435
10436 proc loadVK_IMG_format_pvrtc*(instance: VkInstance) =
10437 discard
10438
10439 proc loadVK_AMD_shader_fragment_mask*(instance: VkInstance) =
10440 discard
10441
10442 proc loadVK_EXT_primitive_topology_list_restart*(instance: VkInstance) =
10443 loadVK_VERSION_1_1(instance)
10444
10445 proc loadVK_KHR_global_priority*(instance: VkInstance) =
10446 loadVK_VERSION_1_1(instance)
10447
10448 proc loadVK_QCOM_image_processing*(instance: VkInstance) =
10449 loadVK_VERSION_1_3(instance)
10450
10451 # extension VK_AMD_shader_info
10452 var
10453 vkGetShaderInfoAMD*: proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr csize_t, pInfo: pointer): VkResult {.stdcall.}
10454 proc loadVK_AMD_shader_info*(instance: VkInstance) =
10455 vkGetShaderInfoAMD = cast[proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr csize_t, pInfo: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetShaderInfoAMD"))
10456
10457 proc loadVK_AMD_gpu_shader_int16*(instance: VkInstance) =
10458 discard
10459
10460 proc loadVK_EXT_pipeline_robustness*(instance: VkInstance) =
10461 loadVK_VERSION_1_1(instance)
10462
10463 # extension VK_EXT_sample_locations
10464 var
10465 vkCmdSetSampleLocationsEXT*: proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT): void {.stdcall.}
10466 vkGetPhysicalDeviceMultisamplePropertiesEXT*: proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT): void {.stdcall.}
10467 proc loadVK_EXT_sample_locations*(instance: VkInstance) =
10468 loadVK_VERSION_1_1(instance)
10469 vkCmdSetSampleLocationsEXT = cast[proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEXT"))
10470 vkGetPhysicalDeviceMultisamplePropertiesEXT = cast[proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
10471
10472 # extension VK_EXT_descriptor_buffer
10473 var
10474 vkGetDescriptorSetLayoutSizeEXT*: proc(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: ptr VkDeviceSize): void {.stdcall.}
10475 vkGetDescriptorSetLayoutBindingOffsetEXT*: proc(device: VkDevice, layout: VkDescriptorSetLayout, binding: uint32, pOffset: ptr VkDeviceSize): void {.stdcall.}
10476 vkGetDescriptorEXT*: proc(device: VkDevice, pDescriptorInfo: ptr VkDescriptorGetInfoEXT, dataSize: csize_t, pDescriptor: pointer): void {.stdcall.}
10477 vkCmdBindDescriptorBuffersEXT*: proc(commandBuffer: VkCommandBuffer, bufferCount: uint32, pBindingInfos: ptr VkDescriptorBufferBindingInfoEXT): void {.stdcall.}
10478 vkCmdSetDescriptorBufferOffsetsEXT*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, setCount: uint32, pBufferIndices: ptr uint32, pOffsets: ptr VkDeviceSize): void {.stdcall.}
10479 vkCmdBindDescriptorBufferEmbeddedSamplersEXT*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32): void {.stdcall.}
10480 vkGetBufferOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkBufferCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}
10481 vkGetImageOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkImageCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}
10482 vkGetImageViewOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkImageViewCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}
10483 vkGetSamplerOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkSamplerCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}
10484 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}
10485 proc loadVK_EXT_descriptor_buffer*(instance: VkInstance) =
10486 loadVK_VERSION_1_1(instance)
10487 loadVK_VERSION_1_2(instance)
10488 loadVK_VERSION_1_3(instance)
10489 loadVK_VERSION_1_2(instance)
10490 vkGetDescriptorSetLayoutSizeEXT = cast[proc(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSizeEXT"))
10491 vkGetDescriptorSetLayoutBindingOffsetEXT = cast[proc(device: VkDevice, layout: VkDescriptorSetLayout, binding: uint32, pOffset: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutBindingOffsetEXT"))
10492 vkGetDescriptorEXT = cast[proc(device: VkDevice, pDescriptorInfo: ptr VkDescriptorGetInfoEXT, dataSize: csize_t, pDescriptor: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorEXT"))
10493 vkCmdBindDescriptorBuffersEXT = cast[proc(commandBuffer: VkCommandBuffer, bufferCount: uint32, pBindingInfos: ptr VkDescriptorBufferBindingInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorBuffersEXT"))
10494 vkCmdSetDescriptorBufferOffsetsEXT = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, setCount: uint32, pBufferIndices: ptr uint32, pOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDescriptorBufferOffsetsEXT"))
10495 vkCmdBindDescriptorBufferEmbeddedSamplersEXT = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT"))
10496 vkGetBufferOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkBufferCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT"))
10497 vkGetImageOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkImageCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageOpaqueCaptureDescriptorDataEXT"))
10498 vkGetImageViewOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkImageViewCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT"))
10499 vkGetSamplerOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkSamplerCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT"))
10500 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"))
10501
10502 # extension VK_KHR_performance_query
10503 var
10504 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32, pCounters: ptr VkPerformanceCounterKHR, pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR): VkResult {.stdcall.}
10505 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR*: proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: ptr uint32): void {.stdcall.}
10506 vkAcquireProfilingLockKHR*: proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR): VkResult {.stdcall.}
10507 vkReleaseProfilingLockKHR*: proc(device: VkDevice): void {.stdcall.}
10508 proc loadVK_KHR_performance_query*(instance: VkInstance) =
10509 loadVK_VERSION_1_1(instance)
10510 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32, pCounters: ptr VkPerformanceCounterKHR, pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))
10511 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: ptr uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))
10512 vkAcquireProfilingLockKHR = cast[proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR"))
10513 vkReleaseProfilingLockKHR = cast[proc(device: VkDevice): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR"))
10514
10515 proc loadVK_GOOGLE_user_type*(instance: VkInstance) =
10516 discard
10517
10518 # extension VK_EXT_debug_report
10519 var
10520 vkCreateDebugReportCallbackEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pCallback: ptr VkDebugReportCallbackEXT): VkResult {.stdcall.}
10521 vkDestroyDebugReportCallbackEXT*: proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10522 vkDebugReportMessageEXT*: proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, theobject: uint64, location: csize_t, messageCode: int32, pLayerPrefix: cstring, pMessage: cstring): void {.stdcall.}
10523 proc loadVK_EXT_debug_report*(instance: VkInstance) =
10524 vkCreateDebugReportCallbackEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pCallback: ptr VkDebugReportCallbackEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT"))
10525 vkDestroyDebugReportCallbackEXT = cast[proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT"))
10526 vkDebugReportMessageEXT = cast[proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, theobject: uint64, location: csize_t, messageCode: int32, pLayerPrefix: cstring, pMessage: cstring): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDebugReportMessageEXT"))
10527
10528 proc loadVK_EXT_multisampled_render_to_single_sampled*(instance: VkInstance) =
10529 loadVK_VERSION_1_2(instance)
10530 loadVK_VERSION_1_2(instance)
10531
10532 proc loadVK_AMD_negative_viewport_height*(instance: VkInstance) =
10533 discard
10534
10535 proc loadVK_EXT_provoking_vertex*(instance: VkInstance) =
10536 loadVK_VERSION_1_1(instance)
10537
10538 proc loadVK_NV_device_diagnostics_config*(instance: VkInstance) =
10539 loadVK_VERSION_1_1(instance)
10540
10541 proc loadVK_NV_shader_subgroup_partitioned*(instance: VkInstance) =
10542 loadVK_VERSION_1_1(instance)
10543
10544 proc loadVK_EXT_image_sliced_view_of_3d*(instance: VkInstance) =
10545 loadVK_VERSION_1_1(instance)
10546 loadVK_VERSION_1_1(instance)
10547
10548 proc loadVK_AMD_shader_image_load_store_lod*(instance: VkInstance) =
10549 discard
10550
10551 proc loadVK_INTEL_shader_integer_functions2*(instance: VkInstance) =
10552 loadVK_VERSION_1_1(instance)
10553
10554 proc loadVK_EXT_image_2d_view_of_3d*(instance: VkInstance) =
10555 loadVK_VERSION_1_1(instance)
10556 loadVK_VERSION_1_1(instance)
10557
10558 # extension VK_NV_shading_rate_image
10559 var
10560 vkCmdBindShadingRateImageNV*: proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}
10561 vkCmdSetViewportShadingRatePaletteNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV): void {.stdcall.}
10562 vkCmdSetCoarseSampleOrderNV*: proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV): void {.stdcall.}
10563 proc loadVK_NV_shading_rate_image*(instance: VkInstance) =
10564 loadVK_VERSION_1_1(instance)
10565 vkCmdBindShadingRateImageNV = cast[proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindShadingRateImageNV"))
10566 vkCmdSetViewportShadingRatePaletteNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportShadingRatePaletteNV"))
10567 vkCmdSetCoarseSampleOrderNV = cast[proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoarseSampleOrderNV"))
10568
10569 proc loadVK_EXT_fragment_density_map*(instance: VkInstance) =
10570 loadVK_VERSION_1_1(instance)
10571
10572 # extension VK_NV_device_diagnostic_checkpoints
10573 var
10574 vkCmdSetCheckpointNV*: proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer): void {.stdcall.}
10575 vkGetQueueCheckpointDataNV*: proc(queue: VkQueue, pCheckpointDataCount: ptr uint32, pCheckpointData: ptr VkCheckpointDataNV): void {.stdcall.}
10576 proc loadVK_NV_device_diagnostic_checkpoints*(instance: VkInstance) =
10577 loadVK_VERSION_1_1(instance)
10578 vkCmdSetCheckpointNV = cast[proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCheckpointNV"))
10579 vkGetQueueCheckpointDataNV = cast[proc(queue: VkQueue, pCheckpointDataCount: ptr uint32, pCheckpointData: ptr VkCheckpointDataNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetQueueCheckpointDataNV"))
10580
10581 proc loadVK_EXT_pci_bus_info*(instance: VkInstance) =
10582 loadVK_VERSION_1_1(instance)
10583
10584 proc loadVK_EXT_queue_family_foreign*(instance: VkInstance) =
10585 loadVK_VERSION_1_1(instance)
10586
10587 # extension VK_EXT_debug_utils
10588 var
10589 vkSetDebugUtilsObjectNameEXT*: proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT): VkResult {.stdcall.}
10590 vkSetDebugUtilsObjectTagEXT*: proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT): VkResult {.stdcall.}
10591 vkQueueBeginDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}
10592 vkQueueEndDebugUtilsLabelEXT*: proc(queue: VkQueue): void {.stdcall.}
10593 vkQueueInsertDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}
10594 vkCmdBeginDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}
10595 vkCmdEndDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
10596 vkCmdInsertDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}
10597 vkCreateDebugUtilsMessengerEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMessenger: ptr VkDebugUtilsMessengerEXT): VkResult {.stdcall.}
10598 vkDestroyDebugUtilsMessengerEXT*: proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10599 vkSubmitDebugUtilsMessageEXT*: proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT): void {.stdcall.}
10600 proc loadVK_EXT_debug_utils*(instance: VkInstance) =
10601 vkSetDebugUtilsObjectNameEXT = cast[proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"))
10602 vkSetDebugUtilsObjectTagEXT = cast[proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT"))
10603 vkQueueBeginDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT"))
10604 vkQueueEndDebugUtilsLabelEXT = cast[proc(queue: VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT"))
10605 vkQueueInsertDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT"))
10606 vkCmdBeginDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT"))
10607 vkCmdEndDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT"))
10608 vkCmdInsertDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT"))
10609 vkCreateDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMessenger: ptr VkDebugUtilsMessengerEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"))
10610 vkDestroyDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"))
10611 vkSubmitDebugUtilsMessageEXT = cast[proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT"))
10612
10613 proc loadVK_KHR_portability_enumeration*(instance: VkInstance) =
10614 discard
10615
10616 proc loadVK_EXT_memory_priority*(instance: VkInstance) =
10617 loadVK_VERSION_1_1(instance)
10618
10619 proc loadVK_AMD_shader_core_properties*(instance: VkInstance) =
10620 loadVK_VERSION_1_1(instance)
10621
10622 # extension VK_KHR_external_fence_fd
10623 var
10624 vkImportFenceFdKHR*: proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR): VkResult {.stdcall.}
10625 vkGetFenceFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}
10626 proc loadVK_KHR_external_fence_fd*(instance: VkInstance) =
10627 loadVK_VERSION_1_1(instance)
10628 vkImportFenceFdKHR = cast[proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkImportFenceFdKHR"))
10629 vkGetFenceFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetFenceFdKHR"))
10630
10631 # extension VK_NV_device_generated_commands
10632 var
10633 vkGetGeneratedCommandsMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}
10634 vkCmdPreprocessGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.}
10635 vkCmdExecuteGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.}
10636 vkCmdBindPipelineShaderGroupNV*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}
10637 vkCreateIndirectCommandsLayoutNV*: proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV): VkResult {.stdcall.}
10638 vkDestroyIndirectCommandsLayoutNV*: proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10639 proc loadVK_NV_device_generated_commands*(instance: VkInstance) =
10640 loadVK_VERSION_1_1(instance)
10641 loadVK_VERSION_1_2(instance)
10642 vkGetGeneratedCommandsMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetGeneratedCommandsMemoryRequirementsNV"))
10643 vkCmdPreprocessGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPreprocessGeneratedCommandsNV"))
10644 vkCmdExecuteGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdExecuteGeneratedCommandsNV"))
10645 vkCmdBindPipelineShaderGroupNV = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindPipelineShaderGroupNV"))
10646 vkCreateIndirectCommandsLayoutNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateIndirectCommandsLayoutNV"))
10647 vkDestroyIndirectCommandsLayoutNV = cast[proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyIndirectCommandsLayoutNV"))
10648
10649 proc loadVK_NV_viewport_array2*(instance: VkInstance) =
10650 discard
10651
10652 proc loadVK_NVX_multiview_per_view_attributes*(instance: VkInstance) =
10653 loadVK_VERSION_1_1(instance)
10654
10655 # extension VK_KHR_external_memory_fd
10656 var
10657 vkGetMemoryFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}
10658 vkGetMemoryFdPropertiesKHR*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: cint, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR): VkResult {.stdcall.}
10659 proc loadVK_KHR_external_memory_fd*(instance: VkInstance) =
10660 loadVK_VERSION_1_1(instance)
10661 vkGetMemoryFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryFdKHR"))
10662 vkGetMemoryFdPropertiesKHR = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: cint, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR"))
10663
10664 proc loadVK_EXT_rgba10x6_formats*(instance: VkInstance) =
10665 loadVK_VERSION_1_1(instance)
10666
10667 proc loadVK_NV_dedicated_allocation_image_aliasing*(instance: VkInstance) =
10668 loadVK_VERSION_1_1(instance)
10669 loadVK_VERSION_1_1(instance)
10670
10671 # extension VK_NV_cooperative_matrix
10672 var
10673 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkCooperativeMatrixPropertiesNV): VkResult {.stdcall.}
10674 proc loadVK_NV_cooperative_matrix*(instance: VkInstance) =
10675 loadVK_VERSION_1_1(instance)
10676 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkCooperativeMatrixPropertiesNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))
10677
10678 proc loadVK_EXT_depth_clamp_zero_one*(instance: VkInstance) =
10679 loadVK_VERSION_1_1(instance)
10680
10681 proc loadVK_NV_linear_color_attachment*(instance: VkInstance) =
10682 loadVK_VERSION_1_1(instance)
10683
10684 proc loadVK_EXT_shader_subgroup_ballot*(instance: VkInstance) =
10685 discard
10686
10687 # extension VK_EXT_image_drm_format_modifier
10688 var
10689 vkGetImageDrmFormatModifierPropertiesEXT*: proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT): VkResult {.stdcall.}
10690 proc loadVK_EXT_image_drm_format_modifier*(instance: VkInstance) =
10691 loadVK_VERSION_1_1(instance)
10692 loadVK_VERSION_1_1(instance)
10693 loadVK_VERSION_1_2(instance)
10694 loadVK_VERSION_1_1(instance)
10695 vkGetImageDrmFormatModifierPropertiesEXT = cast[proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageDrmFormatModifierPropertiesEXT"))
10696
10697 # extension VK_EXT_mesh_shader
10698 var
10699 vkCmdDrawMeshTasksEXT*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
10700 vkCmdDrawMeshTasksIndirectEXT*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
10701 vkCmdDrawMeshTasksIndirectCountEXT*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
10702 proc loadVK_EXT_mesh_shader*(instance: VkInstance) =
10703 loadVK_VERSION_1_2(instance)
10704 vkCmdDrawMeshTasksEXT = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksEXT"))
10705 vkCmdDrawMeshTasksIndirectEXT = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectEXT"))
10706 vkCmdDrawMeshTasksIndirectCountEXT = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountEXT"))
10707
10708 # extension VK_EXT_transform_feedback
10709 var
10710 vkCmdBindTransformFeedbackBuffersEXT*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize): void {.stdcall.}
10711 vkCmdBeginTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.}
10712 vkCmdEndTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.}
10713 vkCmdBeginQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}
10714 vkCmdEndQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}
10715 vkCmdDrawIndirectByteCountEXT*: proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}
10716 proc loadVK_EXT_transform_feedback*(instance: VkInstance) =
10717 loadVK_VERSION_1_1(instance)
10718 vkCmdBindTransformFeedbackBuffersEXT = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindTransformFeedbackBuffersEXT"))
10719 vkCmdBeginTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginTransformFeedbackEXT"))
10720 vkCmdEndTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndTransformFeedbackEXT"))
10721 vkCmdBeginQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT"))
10722 vkCmdEndQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT"))
10723 vkCmdDrawIndirectByteCountEXT = cast[proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT"))
10724
10725 proc loadVK_AMD_shader_early_and_late_fragment_tests*(instance: VkInstance) =
10726 loadVK_VERSION_1_1(instance)
10727
10728 proc loadVK_AMD_shader_core_properties2*(instance: VkInstance) =
10729 loadVK_AMD_shader_core_properties(instance)
10730
10731 proc loadVK_GOOGLE_hlsl_functionality1*(instance: VkInstance) =
10732 discard
10733
10734 proc loadVK_EXT_robustness2*(instance: VkInstance) =
10735 loadVK_VERSION_1_1(instance)
10736
10737 proc loadVK_EXT_image_view_min_lod*(instance: VkInstance) =
10738 loadVK_VERSION_1_1(instance)
10739
10740 proc loadVK_AMD_shader_trinary_minmax*(instance: VkInstance) =
10741 discard
10742
10743 proc loadVK_EXT_custom_border_color*(instance: VkInstance) =
10744 loadVK_VERSION_1_1(instance)
10745
10746 proc loadVK_AMD_rasterization_order*(instance: VkInstance) =
10747 discard
10748
10749 # extension VK_EXT_vertex_input_dynamic_state
10750 var
10751 vkCmdSetVertexInputEXT*: proc(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32, pVertexBindingDescriptions: ptr VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32, pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription2EXT): void {.stdcall.}
10752 proc loadVK_EXT_vertex_input_dynamic_state*(instance: VkInstance) =
10753 loadVK_VERSION_1_1(instance)
10754 vkCmdSetVertexInputEXT = cast[proc(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32, pVertexBindingDescriptions: ptr VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32, pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription2EXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetVertexInputEXT"))
10755
10756 # extension VK_KHR_fragment_shading_rate
10757 var
10758 vkGetPhysicalDeviceFragmentShadingRatesKHR*: proc(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: ptr uint32, pFragmentShadingRates: ptr VkPhysicalDeviceFragmentShadingRateKHR): VkResult {.stdcall.}
10759 vkCmdSetFragmentShadingRateKHR*: proc(commandBuffer: VkCommandBuffer, pFragmentSize: ptr VkExtent2D, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.}
10760 proc loadVK_KHR_fragment_shading_rate*(instance: VkInstance) =
10761 loadVK_VERSION_1_2(instance)
10762 loadVK_VERSION_1_1(instance)
10763 vkGetPhysicalDeviceFragmentShadingRatesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: ptr uint32, pFragmentShadingRates: ptr VkPhysicalDeviceFragmentShadingRateKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"))
10764 vkCmdSetFragmentShadingRateKHR = cast[proc(commandBuffer: VkCommandBuffer, pFragmentSize: ptr VkExtent2D, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateKHR"))
10765
10766 proc loadVK_EXT_depth_clip_enable*(instance: VkInstance) =
10767 loadVK_VERSION_1_1(instance)
10768
10769 proc loadVK_EXT_subpass_merge_feedback*(instance: VkInstance) =
10770 loadVK_VERSION_1_1(instance)
10771
10772 # extension VK_KHR_external_semaphore_fd
10773 var
10774 vkImportSemaphoreFdKHR*: proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR): VkResult {.stdcall.}
10775 vkGetSemaphoreFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}
10776 proc loadVK_KHR_external_semaphore_fd*(instance: VkInstance) =
10777 loadVK_VERSION_1_1(instance)
10778 vkImportSemaphoreFdKHR = cast[proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkImportSemaphoreFdKHR"))
10779 vkGetSemaphoreFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSemaphoreFdKHR"))
10780
10781 proc loadVK_KHR_fragment_shader_barycentric*(instance: VkInstance) =
10782 loadVK_VERSION_1_1(instance)
10783
10784 proc loadVK_EXT_memory_budget*(instance: VkInstance) =
10785 loadVK_VERSION_1_1(instance)
10786
10787 proc loadVK_AMD_device_coherent_memory*(instance: VkInstance) =
10788 loadVK_VERSION_1_1(instance)
10789
10790 proc loadVK_EXT_device_memory_report*(instance: VkInstance) =
10791 loadVK_VERSION_1_1(instance)
10792
10793 proc loadVK_AMD_memory_overallocation_behavior*(instance: VkInstance) =
10794 discard
10795
10796 # extension VK_NV_mesh_shader
10797 var
10798 vkCmdDrawMeshTasksNV*: proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}
10799 vkCmdDrawMeshTasksIndirectNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
10800 vkCmdDrawMeshTasksIndirectCountNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
10801 proc loadVK_NV_mesh_shader*(instance: VkInstance) =
10802 loadVK_VERSION_1_1(instance)
10803 vkCmdDrawMeshTasksNV = cast[proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksNV"))
10804 vkCmdDrawMeshTasksIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectNV"))
10805 vkCmdDrawMeshTasksIndirectCountNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV"))
10806
10807 # extension VK_EXT_image_compression_control
10808 var
10809 vkGetImageSubresourceLayout2EXT*: proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource2EXT, pLayout: ptr VkSubresourceLayout2EXT): void {.stdcall.}
10810 proc loadVK_EXT_image_compression_control*(instance: VkInstance) =
10811 loadVK_VERSION_1_1(instance)
10812 vkGetImageSubresourceLayout2EXT = cast[proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource2EXT, pLayout: ptr VkSubresourceLayout2EXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout2EXT"))
10813
10814 # extension VK_EXT_buffer_device_address
10815 var
10816 vkGetBufferDeviceAddressEXT*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): VkDeviceAddress {.stdcall.}
10817 proc loadVK_EXT_buffer_device_address*(instance: VkInstance) =
10818 loadVK_VERSION_1_1(instance)
10819 vkGetBufferDeviceAddressEXT = vkGetBufferDeviceAddress
10820
10821 proc loadVK_QCOM_render_pass_shader_resolve*(instance: VkInstance) =
10822 discard
10823
10824 proc loadVK_EXT_depth_range_unrestricted*(instance: VkInstance) =
10825 discard
10826
10827 # extension VK_HUAWEI_subpass_shading
10828 var
10829 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI*: proc(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: ptr VkExtent2D): VkResult {.stdcall.}
10830 vkCmdSubpassShadingHUAWEI*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
10831 proc loadVK_HUAWEI_subpass_shading*(instance: VkInstance) =
10832 loadVK_VERSION_1_2(instance)
10833 loadVK_VERSION_1_3(instance)
10834 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = cast[proc(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: ptr VkExtent2D): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"))
10835 vkCmdSubpassShadingHUAWEI = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSubpassShadingHUAWEI"))
10836
10837 # extension VK_VALVE_descriptor_set_host_mapping
10838 var
10839 vkGetDescriptorSetLayoutHostMappingInfoVALVE*: proc(device: VkDevice, pBindingReference: ptr VkDescriptorSetBindingReferenceVALVE, pHostMapping: ptr VkDescriptorSetLayoutHostMappingInfoVALVE): void {.stdcall.}
10840 vkGetDescriptorSetHostMappingVALVE*: proc(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: ptr pointer): void {.stdcall.}
10841 proc loadVK_VALVE_descriptor_set_host_mapping*(instance: VkInstance) =
10842 loadVK_VERSION_1_1(instance)
10843 vkGetDescriptorSetLayoutHostMappingInfoVALVE = cast[proc(device: VkDevice, pBindingReference: ptr VkDescriptorSetBindingReferenceVALVE, pHostMapping: ptr VkDescriptorSetLayoutHostMappingInfoVALVE): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE"))
10844 vkGetDescriptorSetHostMappingVALVE = cast[proc(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: ptr pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetHostMappingVALVE"))
10845
10846 # extension VK_NV_external_memory_capabilities
10847 var
10848 vkGetPhysicalDeviceExternalImageFormatPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV): VkResult {.stdcall.}
10849 proc loadVK_NV_external_memory_capabilities*(instance: VkInstance) =
10850 vkGetPhysicalDeviceExternalImageFormatPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
10851
10852 # extension VK_NV_optical_flow
10853 var
10854 vkGetPhysicalDeviceOpticalFlowImageFormatsNV*: proc(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: ptr VkOpticalFlowImageFormatInfoNV, pFormatCount: ptr uint32, pImageFormatProperties: ptr VkOpticalFlowImageFormatPropertiesNV): VkResult {.stdcall.}
10855 vkCreateOpticalFlowSessionNV*: proc(device: VkDevice, pCreateInfo: ptr VkOpticalFlowSessionCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pSession: ptr VkOpticalFlowSessionNV): VkResult {.stdcall.}
10856 vkDestroyOpticalFlowSessionNV*: proc(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
10857 vkBindOpticalFlowSessionImageNV*: proc(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout): VkResult {.stdcall.}
10858 vkCmdOpticalFlowExecuteNV*: proc(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: ptr VkOpticalFlowExecuteInfoNV): void {.stdcall.}
10859 proc loadVK_NV_optical_flow*(instance: VkInstance) =
10860 loadVK_VERSION_1_1(instance)
10861 loadVK_VERSION_1_3(instance)
10862 loadVK_VERSION_1_3(instance)
10863 vkGetPhysicalDeviceOpticalFlowImageFormatsNV = cast[proc(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: ptr VkOpticalFlowImageFormatInfoNV, pFormatCount: ptr uint32, pImageFormatProperties: ptr VkOpticalFlowImageFormatPropertiesNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"))
10864 vkCreateOpticalFlowSessionNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkOpticalFlowSessionCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pSession: ptr VkOpticalFlowSessionNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateOpticalFlowSessionNV"))
10865 vkDestroyOpticalFlowSessionNV = cast[proc(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyOpticalFlowSessionNV"))
10866 vkBindOpticalFlowSessionImageNV = cast[proc(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindOpticalFlowSessionImageNV"))
10867 vkCmdOpticalFlowExecuteNV = cast[proc(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: ptr VkOpticalFlowExecuteInfoNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdOpticalFlowExecuteNV"))
10868
10869 proc loadVK_EXT_vertex_attribute_divisor*(instance: VkInstance) =
10870 loadVK_VERSION_1_1(instance)
10871
10872 # extension VK_EXT_line_rasterization
10873 var
10874 vkCmdSetLineStippleEXT*: proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}
10875 proc loadVK_EXT_line_rasterization*(instance: VkInstance) =
10876 loadVK_VERSION_1_1(instance)
10877 vkCmdSetLineStippleEXT = cast[proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineStippleEXT"))
10878
10879 proc loadVK_AMD_texture_gather_bias_lod*(instance: VkInstance) =
10880 loadVK_VERSION_1_1(instance)
10881
10882 proc loadVK_KHR_shader_subgroup_uniform_control_flow*(instance: VkInstance) =
10883 loadVK_VERSION_1_1(instance)
10884
10885 proc loadVK_EXT_external_memory_dma_buf*(instance: VkInstance) =
10886 loadVK_KHR_external_memory_fd(instance)
10887
10888 proc loadVK_IMG_filter_cubic*(instance: VkInstance) =
10889 discard
10890
10891 proc loadVK_AMD_shader_ballot*(instance: VkInstance) =
10892 discard
10893
10894 # extension VK_AMD_buffer_marker
10895 var
10896 vkCmdWriteBufferMarkerAMD*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}
10897 proc loadVK_AMD_buffer_marker*(instance: VkInstance) =
10898 vkCmdWriteBufferMarkerAMD = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteBufferMarkerAMD"))
10899
10900 proc loadVK_NV_corner_sampled_image*(instance: VkInstance) =
10901 loadVK_VERSION_1_1(instance)
10902
10903 proc loadVK_KHR_pipeline_library*(instance: VkInstance) =
10904 discard
10905
10906 proc loadVK_EXT_blend_operation_advanced*(instance: VkInstance) =
10907 loadVK_VERSION_1_1(instance)
10908
10909 # extension VK_NV_scissor_exclusive
10910 var
10911 vkCmdSetExclusiveScissorEnableNV*: proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissorEnables: ptr VkBool32): void {.stdcall.}
10912 vkCmdSetExclusiveScissorNV*: proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D): void {.stdcall.}
10913 proc loadVK_NV_scissor_exclusive*(instance: VkInstance) =
10914 loadVK_VERSION_1_1(instance)
10915 vkCmdSetExclusiveScissorEnableNV = cast[proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissorEnables: ptr VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorEnableNV"))
10916 vkCmdSetExclusiveScissorNV = cast[proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorNV"))
10917
10918 proc loadVK_NV_framebuffer_mixed_samples*(instance: VkInstance) =
10919 discard
10920
10921 proc loadVK_NV_sample_mask_override_coverage*(instance: VkInstance) =
10922 discard
10923
10924 proc loadVK_EXT_filter_cubic*(instance: VkInstance) =
10925 discard
10926
10927 # extension VK_KHR_pipeline_executable_properties
10928 var
10929 vkGetPipelineExecutablePropertiesKHR*: proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR, pExecutableCount: ptr uint32, pProperties: ptr VkPipelineExecutablePropertiesKHR): VkResult {.stdcall.}
10930 vkGetPipelineExecutableStatisticsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pStatisticCount: ptr uint32, pStatistics: ptr VkPipelineExecutableStatisticKHR): VkResult {.stdcall.}
10931 vkGetPipelineExecutableInternalRepresentationsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pInternalRepresentationCount: ptr uint32, pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR): VkResult {.stdcall.}
10932 proc loadVK_KHR_pipeline_executable_properties*(instance: VkInstance) =
10933 loadVK_VERSION_1_1(instance)
10934 vkGetPipelineExecutablePropertiesKHR = cast[proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR, pExecutableCount: ptr uint32, pProperties: ptr VkPipelineExecutablePropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineExecutablePropertiesKHR"))
10935 vkGetPipelineExecutableStatisticsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pStatisticCount: ptr uint32, pStatistics: ptr VkPipelineExecutableStatisticKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableStatisticsKHR"))
10936 vkGetPipelineExecutableInternalRepresentationsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pInternalRepresentationCount: ptr uint32, pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableInternalRepresentationsKHR"))
10937
10938 # extension VK_EXT_extended_dynamic_state3
10939 var
10940 vkCmdSetTessellationDomainOriginEXT*: proc(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin): void {.stdcall.}
10941 vkCmdSetDepthClampEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32): void {.stdcall.}
10942 vkCmdSetPolygonModeEXT*: proc(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode): void {.stdcall.}
10943 vkCmdSetRasterizationSamplesEXT*: proc(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits): void {.stdcall.}
10944 vkCmdSetSampleMaskEXT*: proc(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: ptr VkSampleMask): void {.stdcall.}
10945 vkCmdSetAlphaToCoverageEnableEXT*: proc(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32): void {.stdcall.}
10946 vkCmdSetAlphaToOneEnableEXT*: proc(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32): void {.stdcall.}
10947 vkCmdSetLogicOpEnableEXT*: proc(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32): void {.stdcall.}
10948 vkCmdSetColorBlendEnableEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEnables: ptr VkBool32): void {.stdcall.}
10949 vkCmdSetColorBlendEquationEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEquations: ptr VkColorBlendEquationEXT): void {.stdcall.}
10950 vkCmdSetColorWriteMaskEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorWriteMasks: ptr VkColorComponentFlags): void {.stdcall.}
10951 vkCmdSetRasterizationStreamEXT*: proc(commandBuffer: VkCommandBuffer, rasterizationStream: uint32): void {.stdcall.}
10952 vkCmdSetConservativeRasterizationModeEXT*: proc(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT): void {.stdcall.}
10953 vkCmdSetExtraPrimitiveOverestimationSizeEXT*: proc(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float32): void {.stdcall.}
10954 vkCmdSetDepthClipEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32): void {.stdcall.}
10955 vkCmdSetSampleLocationsEnableEXT*: proc(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32): void {.stdcall.}
10956 vkCmdSetColorBlendAdvancedEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendAdvanced: ptr VkColorBlendAdvancedEXT): void {.stdcall.}
10957 vkCmdSetProvokingVertexModeEXT*: proc(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT): void {.stdcall.}
10958 vkCmdSetLineRasterizationModeEXT*: proc(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT): void {.stdcall.}
10959 vkCmdSetLineStippleEnableEXT*: proc(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32): void {.stdcall.}
10960 vkCmdSetDepthClipNegativeOneToOneEXT*: proc(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32): void {.stdcall.}
10961 vkCmdSetViewportWScalingEnableNV*: proc(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32): void {.stdcall.}
10962 vkCmdSetViewportSwizzleNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportSwizzles: ptr VkViewportSwizzleNV): void {.stdcall.}
10963 vkCmdSetCoverageToColorEnableNV*: proc(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32): void {.stdcall.}
10964 vkCmdSetCoverageToColorLocationNV*: proc(commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32): void {.stdcall.}
10965 vkCmdSetCoverageModulationModeNV*: proc(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV): void {.stdcall.}
10966 vkCmdSetCoverageModulationTableEnableNV*: proc(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32): void {.stdcall.}
10967 vkCmdSetCoverageModulationTableNV*: proc(commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32, pCoverageModulationTable: ptr float32): void {.stdcall.}
10968 vkCmdSetShadingRateImageEnableNV*: proc(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32): void {.stdcall.}
10969 vkCmdSetRepresentativeFragmentTestEnableNV*: proc(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32): void {.stdcall.}
10970 vkCmdSetCoverageReductionModeNV*: proc(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV): void {.stdcall.}
10971 proc loadVK_EXT_extended_dynamic_state3*(instance: VkInstance) =
10972 loadVK_VERSION_1_1(instance)
10973 vkCmdSetTessellationDomainOriginEXT = cast[proc(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetTessellationDomainOriginEXT"))
10974 vkCmdSetDepthClampEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthClampEnableEXT"))
10975 vkCmdSetPolygonModeEXT = cast[proc(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPolygonModeEXT"))
10976 vkCmdSetRasterizationSamplesEXT = cast[proc(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRasterizationSamplesEXT"))
10977 vkCmdSetSampleMaskEXT = cast[proc(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: ptr VkSampleMask): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetSampleMaskEXT"))
10978 vkCmdSetAlphaToCoverageEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetAlphaToCoverageEnableEXT"))
10979 vkCmdSetAlphaToOneEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetAlphaToOneEnableEXT"))
10980 vkCmdSetLogicOpEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLogicOpEnableEXT"))
10981 vkCmdSetColorBlendEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEnables: ptr VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorBlendEnableEXT"))
10982 vkCmdSetColorBlendEquationEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEquations: ptr VkColorBlendEquationEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorBlendEquationEXT"))
10983 vkCmdSetColorWriteMaskEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorWriteMasks: ptr VkColorComponentFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorWriteMaskEXT"))
10984 vkCmdSetRasterizationStreamEXT = cast[proc(commandBuffer: VkCommandBuffer, rasterizationStream: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRasterizationStreamEXT"))
10985 vkCmdSetConservativeRasterizationModeEXT = cast[proc(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetConservativeRasterizationModeEXT"))
10986 vkCmdSetExtraPrimitiveOverestimationSizeEXT = cast[proc(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"))
10987 vkCmdSetDepthClipEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthClipEnableEXT"))
10988 vkCmdSetSampleLocationsEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEnableEXT"))
10989 vkCmdSetColorBlendAdvancedEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendAdvanced: ptr VkColorBlendAdvancedEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorBlendAdvancedEXT"))
10990 vkCmdSetProvokingVertexModeEXT = cast[proc(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetProvokingVertexModeEXT"))
10991 vkCmdSetLineRasterizationModeEXT = cast[proc(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineRasterizationModeEXT"))
10992 vkCmdSetLineStippleEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineStippleEnableEXT"))
10993 vkCmdSetDepthClipNegativeOneToOneEXT = cast[proc(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthClipNegativeOneToOneEXT"))
10994 vkCmdSetViewportWScalingEnableNV = cast[proc(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportWScalingEnableNV"))
10995 vkCmdSetViewportSwizzleNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportSwizzles: ptr VkViewportSwizzleNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportSwizzleNV"))
10996 vkCmdSetCoverageToColorEnableNV = cast[proc(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageToColorEnableNV"))
10997 vkCmdSetCoverageToColorLocationNV = cast[proc(commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageToColorLocationNV"))
10998 vkCmdSetCoverageModulationModeNV = cast[proc(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageModulationModeNV"))
10999 vkCmdSetCoverageModulationTableEnableNV = cast[proc(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageModulationTableEnableNV"))
11000 vkCmdSetCoverageModulationTableNV = cast[proc(commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32, pCoverageModulationTable: ptr float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageModulationTableNV"))
11001 vkCmdSetShadingRateImageEnableNV = cast[proc(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetShadingRateImageEnableNV"))
11002 vkCmdSetRepresentativeFragmentTestEnableNV = cast[proc(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRepresentativeFragmentTestEnableNV"))
11003 vkCmdSetCoverageReductionModeNV = cast[proc(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageReductionModeNV"))
11004
11005 proc loadVK_EXT_device_address_binding_report*(instance: VkInstance) =
11006 loadVK_VERSION_1_1(instance)
11007 loadVK_EXT_debug_utils(instance)
11008
11009 # extension VK_NV_clip_space_w_scaling
11010 var
11011 vkCmdSetViewportWScalingNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV): void {.stdcall.}
11012 proc loadVK_NV_clip_space_w_scaling*(instance: VkInstance) =
11013 vkCmdSetViewportWScalingNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportWScalingNV"))
11014
11015 proc loadVK_NV_fill_rectangle*(instance: VkInstance) =
11016 discard
11017
11018 proc loadVK_EXT_shader_image_atomic_int64*(instance: VkInstance) =
11019 loadVK_VERSION_1_1(instance)
11020
11021 proc loadVK_EXT_ycbcr_image_arrays*(instance: VkInstance) =
11022 loadVK_VERSION_1_1(instance)
11023
11024 # extension VK_EXT_calibrated_timestamps
11025 var
11026 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT*: proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32, pTimeDomains: ptr VkTimeDomainEXT): VkResult {.stdcall.}
11027 vkGetCalibratedTimestampsEXT*: proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT, pTimestamps: ptr uint64, pMaxDeviation: ptr uint64): VkResult {.stdcall.}
11028 proc loadVK_EXT_calibrated_timestamps*(instance: VkInstance) =
11029 loadVK_VERSION_1_1(instance)
11030 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = cast[proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32, pTimeDomains: ptr VkTimeDomainEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))
11031 vkGetCalibratedTimestampsEXT = cast[proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT, pTimestamps: ptr uint64, pMaxDeviation: ptr uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT"))
11032
11033 proc loadVK_EXT_attachment_feedback_loop_layout*(instance: VkInstance) =
11034 loadVK_VERSION_1_1(instance)
11035
11036 proc loadVK_AMD_mixed_attachment_samples*(instance: VkInstance) =
11037 discard
11038
11039 # extension VK_EXT_external_memory_host
11040 var
11041 vkGetMemoryHostPointerPropertiesEXT*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer, pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT): VkResult {.stdcall.}
11042 proc loadVK_EXT_external_memory_host*(instance: VkInstance) =
11043 loadVK_VERSION_1_1(instance)
11044 vkGetMemoryHostPointerPropertiesEXT = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer, pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT"))
11045
11046 proc loadVK_ARM_shader_core_properties*(instance: VkInstance) =
11047 loadVK_VERSION_1_1(instance)
11048
11049 # extension VK_EXT_shader_module_identifier
11050 var
11051 vkGetShaderModuleIdentifierEXT*: proc(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.}
11052 vkGetShaderModuleCreateInfoIdentifierEXT*: proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.}
11053 proc loadVK_EXT_shader_module_identifier*(instance: VkInstance) =
11054 loadVK_VERSION_1_1(instance)
11055 loadVK_VERSION_1_3(instance)
11056 vkGetShaderModuleIdentifierEXT = cast[proc(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetShaderModuleIdentifierEXT"))
11057 vkGetShaderModuleCreateInfoIdentifierEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetShaderModuleCreateInfoIdentifierEXT"))
11058
11059 proc loadVK_EXT_border_color_swizzle*(instance: VkInstance) =
11060 loadVK_EXT_custom_border_color(instance)
11061
11062 # extension VK_NV_memory_decompression
11063 var
11064 vkCmdDecompressMemoryNV*: proc(commandBuffer: VkCommandBuffer, decompressRegionCount: uint32, pDecompressMemoryRegions: ptr VkDecompressMemoryRegionNV): void {.stdcall.}
11065 vkCmdDecompressMemoryIndirectCountNV*: proc(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: uint32): void {.stdcall.}
11066 proc loadVK_NV_memory_decompression*(instance: VkInstance) =
11067 loadVK_VERSION_1_1(instance)
11068 loadVK_VERSION_1_2(instance)
11069 vkCmdDecompressMemoryNV = cast[proc(commandBuffer: VkCommandBuffer, decompressRegionCount: uint32, pDecompressMemoryRegions: ptr VkDecompressMemoryRegionNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDecompressMemoryNV"))
11070 vkCmdDecompressMemoryIndirectCountNV = cast[proc(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDecompressMemoryIndirectCountNV"))
11071
11072 proc loadVK_EXT_fragment_shader_interlock*(instance: VkInstance) =
11073 loadVK_VERSION_1_1(instance)
11074
11075 # extension VK_NV_coverage_reduction_mode
11076 var
11077 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV*: proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32, pCombinations: ptr VkFramebufferMixedSamplesCombinationNV): VkResult {.stdcall.}
11078 proc loadVK_NV_coverage_reduction_mode*(instance: VkInstance) =
11079 loadVK_NV_framebuffer_mixed_samples(instance)
11080 loadVK_VERSION_1_1(instance)
11081 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = cast[proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32, pCombinations: ptr VkFramebufferMixedSamplesCombinationNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))
11082
11083 proc loadVK_NV_glsl_shader*(instance: VkInstance) =
11084 discard
11085
11086 proc loadVK_KHR_shader_clock*(instance: VkInstance) =
11087 loadVK_VERSION_1_1(instance)
11088
11089 # extension VK_QCOM_tile_properties
11090 var
11091 vkGetFramebufferTilePropertiesQCOM*: proc(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: ptr uint32, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.}
11092 vkGetDynamicRenderingTilePropertiesQCOM*: proc(device: VkDevice, pRenderingInfo: ptr VkRenderingInfo, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.}
11093 proc loadVK_QCOM_tile_properties*(instance: VkInstance) =
11094 loadVK_VERSION_1_1(instance)
11095 vkGetFramebufferTilePropertiesQCOM = cast[proc(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: ptr uint32, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetFramebufferTilePropertiesQCOM"))
11096 vkGetDynamicRenderingTilePropertiesQCOM = cast[proc(device: VkDevice, pRenderingInfo: ptr VkRenderingInfo, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDynamicRenderingTilePropertiesQCOM"))
11097
11098 # extension VK_KHR_push_descriptor
11099 var
11100 vkCmdPushDescriptorSetKHR*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet): void {.stdcall.}
11101 vkCmdPushDescriptorSetWithTemplateKHR*: proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer): void {.stdcall.}
11102 proc loadVK_KHR_push_descriptor*(instance: VkInstance) =
11103 loadVK_VERSION_1_1(instance)
11104 vkCmdPushDescriptorSetKHR = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetKHR"))
11105 vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR"))
11106 vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR"))
11107
11108 proc loadVK_NV_viewport_swizzle*(instance: VkInstance) =
11109 discard
11110
11111 proc loadVK_NV_external_memory*(instance: VkInstance) =
11112 loadVK_NV_external_memory_capabilities(instance)
11113
11114 proc loadVK_EXT_depth_clip_control*(instance: VkInstance) =
11115 loadVK_VERSION_1_1(instance)
11116
11117 proc loadVK_EXT_validation_flags*(instance: VkInstance) =
11118 discard
11119
11120 proc loadVK_EXT_conservative_rasterization*(instance: VkInstance) =
11121 loadVK_VERSION_1_1(instance)
11122
11123 proc loadVK_AMD_gcn_shader*(instance: VkInstance) =
11124 discard
11125
11126 # extension VK_INTEL_performance_query
11127 var
11128 vkInitializePerformanceApiINTEL*: proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL): VkResult {.stdcall.}
11129 vkUninitializePerformanceApiINTEL*: proc(device: VkDevice): void {.stdcall.}
11130 vkCmdSetPerformanceMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL): VkResult {.stdcall.}
11131 vkCmdSetPerformanceStreamMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL): VkResult {.stdcall.}
11132 vkCmdSetPerformanceOverrideINTEL*: proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL): VkResult {.stdcall.}
11133 vkAcquirePerformanceConfigurationINTEL*: proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: ptr VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
11134 vkReleasePerformanceConfigurationINTEL*: proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
11135 vkQueueSetPerformanceConfigurationINTEL*: proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
11136 vkGetPerformanceParameterINTEL*: proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL): VkResult {.stdcall.}
11137 proc loadVK_INTEL_performance_query*(instance: VkInstance) =
11138 vkInitializePerformanceApiINTEL = cast[proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkInitializePerformanceApiINTEL"))
11139 vkUninitializePerformanceApiINTEL = cast[proc(device: VkDevice): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL"))
11140 vkCmdSetPerformanceMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceMarkerINTEL"))
11141 vkCmdSetPerformanceStreamMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceStreamMarkerINTEL"))
11142 vkCmdSetPerformanceOverrideINTEL = cast[proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceOverrideINTEL"))
11143 vkAcquirePerformanceConfigurationINTEL = cast[proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: ptr VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquirePerformanceConfigurationINTEL"))
11144 vkReleasePerformanceConfigurationINTEL = cast[proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleasePerformanceConfigurationINTEL"))
11145 vkQueueSetPerformanceConfigurationINTEL = cast[proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueSetPerformanceConfigurationINTEL"))
11146 vkGetPerformanceParameterINTEL = cast[proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL"))
11147
11148 proc loadVK_EXT_primitives_generated_query*(instance: VkInstance) =
11149 loadVK_EXT_transform_feedback(instance)
11150
11151 proc loadVK_AMD_pipeline_compiler_control*(instance: VkInstance) =
11152 discard
11153
11154 proc loadVK_EXT_post_depth_coverage*(instance: VkInstance) =
11155 discard
11156
11157 # extension VK_EXT_conditional_rendering
11158 var
11159 vkCmdBeginConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT): void {.stdcall.}
11160 vkCmdEndConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
11161 proc loadVK_EXT_conditional_rendering*(instance: VkInstance) =
11162 loadVK_VERSION_1_1(instance)
11163 vkCmdBeginConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginConditionalRenderingEXT"))
11164 vkCmdEndConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndConditionalRenderingEXT"))
11165
11166 proc loadVK_QCOM_multiview_per_view_viewports*(instance: VkInstance) =
11167 loadVK_VERSION_1_1(instance)
11168
11169 # extension VK_EXT_multi_draw
11170 var
11171 vkCmdDrawMultiEXT*: proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pVertexInfo: ptr VkMultiDrawInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32): void {.stdcall.}
11172 vkCmdDrawMultiIndexedEXT*: proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pIndexInfo: ptr VkMultiDrawIndexedInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32, pVertexOffset: ptr int32): void {.stdcall.}
11173 proc loadVK_EXT_multi_draw*(instance: VkInstance) =
11174 loadVK_VERSION_1_1(instance)
11175 vkCmdDrawMultiEXT = cast[proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pVertexInfo: ptr VkMultiDrawInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMultiEXT"))
11176 vkCmdDrawMultiIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pIndexInfo: ptr VkMultiDrawIndexedInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32, pVertexOffset: ptr int32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMultiIndexedEXT"))
11177
11178 proc loadVK_NV_fragment_coverage_to_color*(instance: VkInstance) =
11179 discard
11180
11181 proc loadVK_EXT_load_store_op_none*(instance: VkInstance) =
11182 discard
11183
11184 proc loadVK_EXT_validation_features*(instance: VkInstance) =
11185 discard
11186
11187 proc loadVK_KHR_workgroup_memory_explicit_layout*(instance: VkInstance) =
11188 loadVK_VERSION_1_1(instance)
11189
11190 proc loadVK_EXT_index_type_uint8*(instance: VkInstance) =
11191 loadVK_VERSION_1_1(instance)
11192
11193 proc loadVK_GOOGLE_decorate_string*(instance: VkInstance) =
11194 discard
11195
11196 proc loadVK_EXT_shader_atomic_float*(instance: VkInstance) =
11197 loadVK_VERSION_1_1(instance)
11198
11199 # extension VK_EXT_pipeline_properties
11200 var
11201 vkGetPipelinePropertiesEXT*: proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoEXT, pPipelineProperties: ptr VkBaseOutStructure): VkResult {.stdcall.}
11202 proc loadVK_EXT_pipeline_properties*(instance: VkInstance) =
11203 loadVK_VERSION_1_1(instance)
11204 vkGetPipelinePropertiesEXT = cast[proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoEXT, pPipelineProperties: ptr VkBaseOutStructure): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelinePropertiesEXT"))
11205
11206 proc loadVK_EXT_graphics_pipeline_library*(instance: VkInstance) =
11207 loadVK_VERSION_1_1(instance)
11208 loadVK_KHR_pipeline_library(instance)
11209
11210 # extension VK_KHR_surface
11211 var
11212 vkDestroySurfaceKHR*: proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11213 vkGetPhysicalDeviceSurfaceSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32): VkResult {.stdcall.}
11214 vkGetPhysicalDeviceSurfaceCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR): VkResult {.stdcall.}
11215 vkGetPhysicalDeviceSurfaceFormatsKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormatKHR): VkResult {.stdcall.}
11216 vkGetPhysicalDeviceSurfacePresentModesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32, pPresentModes: ptr VkPresentModeKHR): VkResult {.stdcall.}
11217 proc loadVK_KHR_surface*(instance: VkInstance) =
11218 vkDestroySurfaceKHR = cast[proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"))
11219 vkGetPhysicalDeviceSurfaceSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"))
11220 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
11221 vkGetPhysicalDeviceSurfaceFormatsKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormatKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
11222 vkGetPhysicalDeviceSurfacePresentModesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32, pPresentModes: ptr VkPresentModeKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
11223
11224 proc loadVK_AMD_gpu_shader_half_float*(instance: VkInstance) =
11225 discard
11226
11227 # extension VK_KHR_deferred_host_operations
11228 var
11229 vkCreateDeferredOperationKHR*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks, pDeferredOperation: ptr VkDeferredOperationKHR): VkResult {.stdcall.}
11230 vkDestroyDeferredOperationKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11231 vkGetDeferredOperationMaxConcurrencyKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}
11232 vkGetDeferredOperationResultKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}
11233 vkDeferredOperationJoinKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}
11234 proc loadVK_KHR_deferred_host_operations*(instance: VkInstance) =
11235 vkCreateDeferredOperationKHR = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks, pDeferredOperation: ptr VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDeferredOperationKHR"))
11236 vkDestroyDeferredOperationKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDeferredOperationKHR"))
11237 vkGetDeferredOperationMaxConcurrencyKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR"))
11238 vkGetDeferredOperationResultKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR"))
11239 vkDeferredOperationJoinKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDeferredOperationJoinKHR"))
11240
11241 proc loadVK_NV_dedicated_allocation*(instance: VkInstance) =
11242 discard
11243
11244 # extension VK_NVX_image_view_handle
11245 var
11246 vkGetImageViewHandleNVX*: proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX): uint32 {.stdcall.}
11247 vkGetImageViewAddressNVX*: proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX): VkResult {.stdcall.}
11248 proc loadVK_NVX_image_view_handle*(instance: VkInstance) =
11249 vkGetImageViewHandleNVX = cast[proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX): uint32 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageViewHandleNVX"))
11250 vkGetImageViewAddressNVX = cast[proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageViewAddressNVX"))
11251
11252 proc loadVK_EXT_non_seamless_cube_map*(instance: VkInstance) =
11253 loadVK_VERSION_1_1(instance)
11254
11255 proc loadVK_QCOM_render_pass_store_ops*(instance: VkInstance) =
11256 discard
11257
11258 # extension VK_EXT_device_fault
11259 var
11260 vkGetDeviceFaultInfoEXT*: proc(device: VkDevice, pFaultCounts: ptr VkDeviceFaultCountsEXT, pFaultInfo: ptr VkDeviceFaultInfoEXT): VkResult {.stdcall.}
11261 proc loadVK_EXT_device_fault*(instance: VkInstance) =
11262 loadVK_VERSION_1_1(instance)
11263 vkGetDeviceFaultInfoEXT = cast[proc(device: VkDevice, pFaultCounts: ptr VkDeviceFaultCountsEXT, pFaultInfo: ptr VkDeviceFaultInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceFaultInfoEXT"))
11264
11265 proc loadVK_EXT_mutable_descriptor_type*(instance: VkInstance) =
11266 loadVK_VERSION_1_1(instance)
11267
11268 # extension VK_EXT_color_write_enable
11269 var
11270 vkCmdSetColorWriteEnableEXT*: proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pColorWriteEnables: ptr VkBool32): void {.stdcall.}
11271 proc loadVK_EXT_color_write_enable*(instance: VkInstance) =
11272 loadVK_VERSION_1_1(instance)
11273 vkCmdSetColorWriteEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pColorWriteEnables: ptr VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorWriteEnableEXT"))
11274
11275 proc loadVK_SEC_amigo_profiling*(instance: VkInstance) =
11276 loadVK_VERSION_1_1(instance)
11277
11278 # extension VK_NVX_binary_import
11279 var
11280 vkCreateCuModuleNVX*: proc(device: VkDevice, pCreateInfo: ptr VkCuModuleCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pModule: ptr VkCuModuleNVX): VkResult {.stdcall.}
11281 vkCreateCuFunctionNVX*: proc(device: VkDevice, pCreateInfo: ptr VkCuFunctionCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pFunction: ptr VkCuFunctionNVX): VkResult {.stdcall.}
11282 vkDestroyCuModuleNVX*: proc(device: VkDevice, module: VkCuModuleNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11283 vkDestroyCuFunctionNVX*: proc(device: VkDevice, function: VkCuFunctionNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11284 vkCmdCuLaunchKernelNVX*: proc(commandBuffer: VkCommandBuffer, pLaunchInfo: ptr VkCuLaunchInfoNVX): void {.stdcall.}
11285 proc loadVK_NVX_binary_import*(instance: VkInstance) =
11286 vkCreateCuModuleNVX = cast[proc(device: VkDevice, pCreateInfo: ptr VkCuModuleCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pModule: ptr VkCuModuleNVX): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateCuModuleNVX"))
11287 vkCreateCuFunctionNVX = cast[proc(device: VkDevice, pCreateInfo: ptr VkCuFunctionCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pFunction: ptr VkCuFunctionNVX): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateCuFunctionNVX"))
11288 vkDestroyCuModuleNVX = cast[proc(device: VkDevice, module: VkCuModuleNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyCuModuleNVX"))
11289 vkDestroyCuFunctionNVX = cast[proc(device: VkDevice, function: VkCuFunctionNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyCuFunctionNVX"))
11290 vkCmdCuLaunchKernelNVX = cast[proc(commandBuffer: VkCommandBuffer, pLaunchInfo: ptr VkCuLaunchInfoNVX): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCuLaunchKernelNVX"))
11291
11292 proc loadVK_NV_representative_fragment_test*(instance: VkInstance) =
11293 loadVK_VERSION_1_1(instance)
11294
11295 # extension VK_EXT_validation_cache
11296 var
11297 vkCreateValidationCacheEXT*: proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pValidationCache: ptr VkValidationCacheEXT): VkResult {.stdcall.}
11298 vkDestroyValidationCacheEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11299 vkMergeValidationCachesEXT*: proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT): VkResult {.stdcall.}
11300 vkGetValidationCacheDataEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.}
11301 proc loadVK_EXT_validation_cache*(instance: VkInstance) =
11302 vkCreateValidationCacheEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pValidationCache: ptr VkValidationCacheEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateValidationCacheEXT"))
11303 vkDestroyValidationCacheEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyValidationCacheEXT"))
11304 vkMergeValidationCachesEXT = cast[proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkMergeValidationCachesEXT"))
11305 vkGetValidationCacheDataEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetValidationCacheDataEXT"))
11306
11307 proc loadVK_NV_inherited_viewport_scissor*(instance: VkInstance) =
11308 loadVK_VERSION_1_1(instance)
11309
11310 proc loadVK_EXT_legacy_dithering*(instance: VkInstance) =
11311 loadVK_VERSION_1_1(instance)
11312
11313 proc loadVK_EXT_physical_device_drm*(instance: VkInstance) =
11314 loadVK_VERSION_1_1(instance)
11315
11316 proc loadVK_EXT_pipeline_protected_access*(instance: VkInstance) =
11317 loadVK_VERSION_1_1(instance)
11318
11319 # extension VK_EXT_discard_rectangles
11320 var
11321 vkCmdSetDiscardRectangleEXT*: proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D): void {.stdcall.}
11322 vkCmdSetDiscardRectangleEnableEXT*: proc(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32): void {.stdcall.}
11323 vkCmdSetDiscardRectangleModeEXT*: proc(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT): void {.stdcall.}
11324 proc loadVK_EXT_discard_rectangles*(instance: VkInstance) =
11325 loadVK_VERSION_1_1(instance)
11326 vkCmdSetDiscardRectangleEXT = cast[proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEXT"))
11327 vkCmdSetDiscardRectangleEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEnableEXT"))
11328 vkCmdSetDiscardRectangleModeEXT = cast[proc(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleModeEXT"))
11329
11330 proc loadVK_EXT_shader_stencil_export*(instance: VkInstance) =
11331 discard
11332
11333 # extension VK_NV_external_memory_rdma
11334 var
11335 vkGetMemoryRemoteAddressNV*: proc(device: VkDevice, pMemoryGetRemoteAddressInfo: ptr VkMemoryGetRemoteAddressInfoNV, pAddress: ptr VkRemoteAddressNV): VkResult {.stdcall.}
11336 proc loadVK_NV_external_memory_rdma*(instance: VkInstance) =
11337 loadVK_VERSION_1_1(instance)
11338 vkGetMemoryRemoteAddressNV = cast[proc(device: VkDevice, pMemoryGetRemoteAddressInfo: ptr VkMemoryGetRemoteAddressInfoNV, pAddress: ptr VkRemoteAddressNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV"))
11339
11340 proc loadVK_ARM_shader_core_builtins*(instance: VkInstance) =
11341 loadVK_VERSION_1_1(instance)
11342
11343 proc loadVK_QCOM_multiview_per_view_render_areas*(instance: VkInstance) =
11344 discard
11345
11346 proc loadVK_LUNARG_direct_driver_loading*(instance: VkInstance) =
11347 discard
11348
11349 proc loadVK_AMD_shader_explicit_vertex_parameter*(instance: VkInstance) =
11350 discard
11351
11352 # extension VK_EXT_headless_surface
11353 var
11354 vkCreateHeadlessSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.}
11355 proc loadVK_EXT_headless_surface*(instance: VkInstance) =
11356 loadVK_KHR_surface(instance)
11357 vkCreateHeadlessSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateHeadlessSurfaceEXT"))
11358
11359 proc loadVK_NV_shader_sm_builtins*(instance: VkInstance) =
11360 loadVK_VERSION_1_1(instance)
11361
11362 proc loadVK_EXT_shader_subgroup_vote*(instance: VkInstance) =
11363 discard
11364
11365 # extension VK_NV_copy_memory_indirect
11366 var
11367 vkCmdCopyMemoryIndirectNV*: proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32): void {.stdcall.}
11368 vkCmdCopyMemoryToImageIndirectNV*: proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: ptr VkImageSubresourceLayers): void {.stdcall.}
11369 proc loadVK_NV_copy_memory_indirect*(instance: VkInstance) =
11370 loadVK_VERSION_1_1(instance)
11371 loadVK_VERSION_1_2(instance)
11372 vkCmdCopyMemoryIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryIndirectNV"))
11373 vkCmdCopyMemoryToImageIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: ptr VkImageSubresourceLayers): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToImageIndirectNV"))
11374
11375 proc loadVK_EXT_astc_decode_mode*(instance: VkInstance) =
11376 loadVK_VERSION_1_1(instance)
11377
11378 # extension VK_KHR_get_surface_capabilities2
11379 var
11380 vkGetPhysicalDeviceSurfaceCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR): VkResult {.stdcall.}
11381 vkGetPhysicalDeviceSurfaceFormats2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormat2KHR): VkResult {.stdcall.}
11382 proc loadVK_KHR_get_surface_capabilities2*(instance: VkInstance) =
11383 loadVK_KHR_surface(instance)
11384 vkGetPhysicalDeviceSurfaceCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
11385 vkGetPhysicalDeviceSurfaceFormats2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormat2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
11386
11387 # extension VK_HUAWEI_cluster_culling_shader
11388 var
11389 vkCmdDrawClusterHUAWEI*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
11390 vkCmdDrawClusterIndirectHUAWEI*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}
11391 proc loadVK_HUAWEI_cluster_culling_shader*(instance: VkInstance) =
11392 loadVK_VERSION_1_1(instance)
11393 vkCmdDrawClusterHUAWEI = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawClusterHUAWEI"))
11394 vkCmdDrawClusterIndirectHUAWEI = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawClusterIndirectHUAWEI"))
11395
11396 proc loadVK_KHR_surface_protected_capabilities*(instance: VkInstance) =
11397 loadVK_VERSION_1_1(instance)
11398 loadVK_KHR_get_surface_capabilities2(instance)
11399
11400 proc loadVK_NV_shader_image_footprint*(instance: VkInstance) =
11401 loadVK_VERSION_1_1(instance)
11402
11403 proc loadVK_NV_compute_shader_derivatives*(instance: VkInstance) =
11404 loadVK_VERSION_1_1(instance)
11405
11406 proc loadVK_QCOM_fragment_density_map_offset*(instance: VkInstance) =
11407 loadVK_VERSION_1_1(instance)
11408 loadVK_EXT_fragment_density_map(instance)
11409
11410 proc loadVK_EXT_shader_atomic_float2*(instance: VkInstance) =
11411 loadVK_EXT_shader_atomic_float(instance)
11412
11413 # extension VK_EXT_pageable_device_local_memory
11414 var
11415 vkSetDeviceMemoryPriorityEXT*: proc(device: VkDevice, memory: VkDeviceMemory, priority: float32): void {.stdcall.}
11416 proc loadVK_EXT_pageable_device_local_memory*(instance: VkInstance) =
11417 loadVK_EXT_memory_priority(instance)
11418 vkSetDeviceMemoryPriorityEXT = cast[proc(device: VkDevice, memory: VkDeviceMemory, priority: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDeviceMemoryPriorityEXT"))
11419
11420 # extension VK_KHR_swapchain
11421 var
11422 vkCreateSwapchainKHR*: proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchain: ptr VkSwapchainKHR): VkResult {.stdcall.}
11423 vkDestroySwapchainKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11424 vkGetSwapchainImagesKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32, pSwapchainImages: ptr VkImage): VkResult {.stdcall.}
11425 vkAcquireNextImageKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32): VkResult {.stdcall.}
11426 vkQueuePresentKHR*: proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR): VkResult {.stdcall.}
11427 vkGetDeviceGroupPresentCapabilitiesKHR*: proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR): VkResult {.stdcall.}
11428 vkGetDeviceGroupSurfacePresentModesKHR*: proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR): VkResult {.stdcall.}
11429 vkGetPhysicalDevicePresentRectanglesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32, pRects: ptr VkRect2D): VkResult {.stdcall.}
11430 vkAcquireNextImage2KHR*: proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR, pImageIndex: ptr uint32): VkResult {.stdcall.}
11431 proc loadVK_KHR_swapchain*(instance: VkInstance) =
11432 loadVK_KHR_surface(instance)
11433 vkCreateSwapchainKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchain: ptr VkSwapchainKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSwapchainKHR"))
11434 vkDestroySwapchainKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySwapchainKHR"))
11435 vkGetSwapchainImagesKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32, pSwapchainImages: ptr VkImage): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR"))
11436 vkAcquireNextImageKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireNextImageKHR"))
11437 vkQueuePresentKHR = cast[proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueuePresentKHR"))
11438 vkGetDeviceGroupPresentCapabilitiesKHR = cast[proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPresentCapabilitiesKHR"))
11439 vkGetDeviceGroupSurfacePresentModesKHR = cast[proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModesKHR"))
11440 vkGetPhysicalDevicePresentRectanglesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32, pRects: ptr VkRect2D): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR"))
11441 vkAcquireNextImage2KHR = cast[proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR, pImageIndex: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireNextImage2KHR"))
11442
11443 proc loadVK_EXT_fragment_density_map2*(instance: VkInstance) =
11444 loadVK_EXT_fragment_density_map(instance)
11445
11446 # extension VK_NV_fragment_shading_rate_enums
11447 var
11448 vkCmdSetFragmentShadingRateEnumNV*: proc(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.}
11449 proc loadVK_NV_fragment_shading_rate_enums*(instance: VkInstance) =
11450 loadVK_KHR_fragment_shading_rate(instance)
11451 vkCmdSetFragmentShadingRateEnumNV = cast[proc(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateEnumNV"))
11452
11453 # extension VK_AMD_display_native_hdr
11454 var
11455 vkSetLocalDimmingAMD*: proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}
11456 proc loadVK_AMD_display_native_hdr*(instance: VkInstance) =
11457 loadVK_VERSION_1_1(instance)
11458 loadVK_KHR_get_surface_capabilities2(instance)
11459 loadVK_KHR_swapchain(instance)
11460 vkSetLocalDimmingAMD = cast[proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetLocalDimmingAMD"))
11461
11462 proc loadVK_NV_present_barrier*(instance: VkInstance) =
11463 loadVK_VERSION_1_1(instance)
11464 loadVK_KHR_surface(instance)
11465 loadVK_KHR_get_surface_capabilities2(instance)
11466 loadVK_KHR_swapchain(instance)
11467
11468 proc loadVK_QCOM_rotated_copy_commands*(instance: VkInstance) =
11469 loadVK_KHR_swapchain(instance)
11470 loadVK_VERSION_1_3(instance)
11471
11472 proc loadVK_EXT_surface_maintenance1*(instance: VkInstance) =
11473 loadVK_KHR_surface(instance)
11474 loadVK_KHR_get_surface_capabilities2(instance)
11475
11476 # extension VK_KHR_acceleration_structure
11477 var
11478 vkCreateAccelerationStructureKHR*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureKHR): VkResult {.stdcall.}
11479 vkDestroyAccelerationStructureKHR*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11480 vkCmdBuildAccelerationStructuresKHR*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): void {.stdcall.}
11481 vkCmdBuildAccelerationStructuresIndirectKHR*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: ptr VkDeviceAddress, pIndirectStrides: ptr uint32, ppMaxPrimitiveCounts: ptr ptr uint32): void {.stdcall.}
11482 vkBuildAccelerationStructuresKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): VkResult {.stdcall.}
11483 vkCopyAccelerationStructureKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureInfoKHR): VkResult {.stdcall.}
11484 vkCopyAccelerationStructureToMemoryKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): VkResult {.stdcall.}
11485 vkCopyMemoryToAccelerationStructureKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): VkResult {.stdcall.}
11486 vkWriteAccelerationStructuresPropertiesKHR*: proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: csize_t, pData: pointer, stride: csize_t): VkResult {.stdcall.}
11487 vkCmdCopyAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR): void {.stdcall.}
11488 vkCmdCopyAccelerationStructureToMemoryKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): void {.stdcall.}
11489 vkCmdCopyMemoryToAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): void {.stdcall.}
11490 vkGetAccelerationStructureDeviceAddressKHR*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR): VkDeviceAddress {.stdcall.}
11491 vkCmdWriteAccelerationStructuresPropertiesKHR*: proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}
11492 vkGetDeviceAccelerationStructureCompatibilityKHR*: proc(device: VkDevice, pVersionInfo: ptr VkAccelerationStructureVersionInfoKHR, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.}
11493 vkGetAccelerationStructureBuildSizesKHR*: proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: ptr uint32, pSizeInfo: ptr VkAccelerationStructureBuildSizesInfoKHR): void {.stdcall.}
11494 proc loadVK_KHR_acceleration_structure*(instance: VkInstance) =
11495 loadVK_VERSION_1_1(instance)
11496 loadVK_VERSION_1_2(instance)
11497 loadVK_VERSION_1_2(instance)
11498 loadVK_KHR_deferred_host_operations(instance)
11499 vkCreateAccelerationStructureKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureKHR"))
11500 vkDestroyAccelerationStructureKHR = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureKHR"))
11501 vkCmdBuildAccelerationStructuresKHR = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR"))
11502 vkCmdBuildAccelerationStructuresIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: ptr VkDeviceAddress, pIndirectStrides: ptr uint32, ppMaxPrimitiveCounts: ptr ptr uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresIndirectKHR"))
11503 vkBuildAccelerationStructuresKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBuildAccelerationStructuresKHR"))
11504 vkCopyAccelerationStructureKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR"))
11505 vkCopyAccelerationStructureToMemoryKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR"))
11506 vkCopyMemoryToAccelerationStructureKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMemoryToAccelerationStructureKHR"))
11507 vkWriteAccelerationStructuresPropertiesKHR = cast[proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: csize_t, pData: pointer, stride: csize_t): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWriteAccelerationStructuresPropertiesKHR"))
11508 vkCmdCopyAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR"))
11509 vkCmdCopyAccelerationStructureToMemoryKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR"))
11510 vkCmdCopyMemoryToAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToAccelerationStructureKHR"))
11511 vkGetAccelerationStructureDeviceAddressKHR = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR): VkDeviceAddress {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureDeviceAddressKHR"))
11512 vkCmdWriteAccelerationStructuresPropertiesKHR = cast[proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesKHR"))
11513 vkGetDeviceAccelerationStructureCompatibilityKHR = cast[proc(device: VkDevice, pVersionInfo: ptr VkAccelerationStructureVersionInfoKHR, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceAccelerationStructureCompatibilityKHR"))
11514 vkGetAccelerationStructureBuildSizesKHR = cast[proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: ptr uint32, pSizeInfo: ptr VkAccelerationStructureBuildSizesInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureBuildSizesKHR"))
11515
11516 # extension VK_GOOGLE_display_timing
11517 var
11518 vkGetRefreshCycleDurationGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE): VkResult {.stdcall.}
11519 vkGetPastPresentationTimingGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32, pPresentationTimings: ptr VkPastPresentationTimingGOOGLE): VkResult {.stdcall.}
11520 proc loadVK_GOOGLE_display_timing*(instance: VkInstance) =
11521 loadVK_KHR_swapchain(instance)
11522 vkGetRefreshCycleDurationGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE"))
11523 vkGetPastPresentationTimingGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32, pPresentationTimings: ptr VkPastPresentationTimingGOOGLE): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE"))
11524
11525 proc loadVK_QCOM_render_pass_transform*(instance: VkInstance) =
11526 loadVK_KHR_swapchain(instance)
11527 loadVK_KHR_surface(instance)
11528
11529 proc loadVK_GOOGLE_surfaceless_query*(instance: VkInstance) =
11530 loadVK_KHR_surface(instance)
11531
11532 proc loadVK_EXT_image_compression_control_swapchain*(instance: VkInstance) =
11533 loadVK_EXT_image_compression_control(instance)
11534
11535 # extension VK_KHR_display
11536 var
11537 vkGetPhysicalDeviceDisplayPropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPropertiesKHR): VkResult {.stdcall.}
11538 vkGetPhysicalDeviceDisplayPlanePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlanePropertiesKHR): VkResult {.stdcall.}
11539 vkGetDisplayPlaneSupportedDisplaysKHR*: proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32, pDisplays: ptr VkDisplayKHR): VkResult {.stdcall.}
11540 vkGetDisplayModePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModePropertiesKHR): VkResult {.stdcall.}
11541 vkCreateDisplayModeKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pMode: ptr VkDisplayModeKHR): VkResult {.stdcall.}
11542 vkGetDisplayPlaneCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR): VkResult {.stdcall.}
11543 vkCreateDisplayPlaneSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.}
11544 proc loadVK_KHR_display*(instance: VkInstance) =
11545 loadVK_KHR_surface(instance)
11546 vkGetPhysicalDeviceDisplayPropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
11547 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlanePropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
11548 vkGetDisplayPlaneSupportedDisplaysKHR = cast[proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32, pDisplays: ptr VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR"))
11549 vkGetDisplayModePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModePropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayModePropertiesKHR"))
11550 vkCreateDisplayModeKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pMode: ptr VkDisplayModeKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDisplayModeKHR"))
11551 vkGetDisplayPlaneCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR"))
11552 vkCreateDisplayPlaneSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDisplayPlaneSurfaceKHR"))
11553
11554 # extension VK_EXT_swapchain_maintenance1
11555 var
11556 vkReleaseSwapchainImagesEXT*: proc(device: VkDevice, pReleaseInfo: ptr VkReleaseSwapchainImagesInfoEXT): VkResult {.stdcall.}
11557 proc loadVK_EXT_swapchain_maintenance1*(instance: VkInstance) =
11558 loadVK_KHR_swapchain(instance)
11559 loadVK_EXT_surface_maintenance1(instance)
11560 loadVK_VERSION_1_1(instance)
11561 vkReleaseSwapchainImagesEXT = cast[proc(device: VkDevice, pReleaseInfo: ptr VkReleaseSwapchainImagesInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleaseSwapchainImagesEXT"))
11562
11563 # extension VK_EXT_direct_mode_display
11564 var
11565 vkReleaseDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}
11566 proc loadVK_EXT_direct_mode_display*(instance: VkInstance) =
11567 loadVK_KHR_display(instance)
11568 vkReleaseDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT"))
11569
11570 proc loadVK_KHR_swapchain_mutable_format*(instance: VkInstance) =
11571 loadVK_KHR_swapchain(instance)
11572 loadVK_VERSION_1_1(instance)
11573 loadVK_VERSION_1_2(instance)
11574
11575 proc loadVK_EXT_swapchain_colorspace*(instance: VkInstance) =
11576 loadVK_KHR_surface(instance)
11577
11578 # extension VK_EXT_opacity_micromap
11579 var
11580 vkCreateMicromapEXT*: proc(device: VkDevice, pCreateInfo: ptr VkMicromapCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMicromap: ptr VkMicromapEXT): VkResult {.stdcall.}
11581 vkDestroyMicromapEXT*: proc(device: VkDevice, micromap: VkMicromapEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11582 vkCmdBuildMicromapsEXT*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): void {.stdcall.}
11583 vkBuildMicromapsEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): VkResult {.stdcall.}
11584 vkCopyMicromapEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapInfoEXT): VkResult {.stdcall.}
11585 vkCopyMicromapToMemoryEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): VkResult {.stdcall.}
11586 vkCopyMemoryToMicromapEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): VkResult {.stdcall.}
11587 vkWriteMicromapsPropertiesEXT*: proc(device: VkDevice, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, dataSize: csize_t, pData: pointer, stride: csize_t): VkResult {.stdcall.}
11588 vkCmdCopyMicromapEXT*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapInfoEXT): void {.stdcall.}
11589 vkCmdCopyMicromapToMemoryEXT*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): void {.stdcall.}
11590 vkCmdCopyMemoryToMicromapEXT*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): void {.stdcall.}
11591 vkCmdWriteMicromapsPropertiesEXT*: proc(commandBuffer: VkCommandBuffer, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}
11592 vkGetDeviceMicromapCompatibilityEXT*: proc(device: VkDevice, pVersionInfo: ptr VkMicromapVersionInfoEXT, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.}
11593 vkGetMicromapBuildSizesEXT*: proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkMicromapBuildInfoEXT, pSizeInfo: ptr VkMicromapBuildSizesInfoEXT): void {.stdcall.}
11594 proc loadVK_EXT_opacity_micromap*(instance: VkInstance) =
11595 loadVK_KHR_acceleration_structure(instance)
11596 loadVK_VERSION_1_3(instance)
11597 vkCreateMicromapEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkMicromapCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMicromap: ptr VkMicromapEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateMicromapEXT"))
11598 vkDestroyMicromapEXT = cast[proc(device: VkDevice, micromap: VkMicromapEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyMicromapEXT"))
11599 vkCmdBuildMicromapsEXT = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBuildMicromapsEXT"))
11600 vkBuildMicromapsEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBuildMicromapsEXT"))
11601 vkCopyMicromapEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMicromapEXT"))
11602 vkCopyMicromapToMemoryEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMicromapToMemoryEXT"))
11603 vkCopyMemoryToMicromapEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMemoryToMicromapEXT"))
11604 vkWriteMicromapsPropertiesEXT = cast[proc(device: VkDevice, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, dataSize: csize_t, pData: pointer, stride: csize_t): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWriteMicromapsPropertiesEXT"))
11605 vkCmdCopyMicromapEXT = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMicromapEXT"))
11606 vkCmdCopyMicromapToMemoryEXT = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMicromapToMemoryEXT"))
11607 vkCmdCopyMemoryToMicromapEXT = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToMicromapEXT"))
11608 vkCmdWriteMicromapsPropertiesEXT = cast[proc(commandBuffer: VkCommandBuffer, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteMicromapsPropertiesEXT"))
11609 vkGetDeviceMicromapCompatibilityEXT = cast[proc(device: VkDevice, pVersionInfo: ptr VkMicromapVersionInfoEXT, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceMicromapCompatibilityEXT"))
11610 vkGetMicromapBuildSizesEXT = cast[proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkMicromapBuildInfoEXT, pSizeInfo: ptr VkMicromapBuildSizesInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMicromapBuildSizesEXT"))
11611
11612 proc loadVK_KHR_incremental_present*(instance: VkInstance) =
11613 loadVK_KHR_swapchain(instance)
11614
11615 # extension VK_KHR_shared_presentable_image
11616 var
11617 vkGetSwapchainStatusKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
11618 proc loadVK_KHR_shared_presentable_image*(instance: VkInstance) =
11619 loadVK_KHR_swapchain(instance)
11620 loadVK_VERSION_1_1(instance)
11621 loadVK_KHR_get_surface_capabilities2(instance)
11622 vkGetSwapchainStatusKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSwapchainStatusKHR"))
11623
11624 # extension VK_EXT_hdr_metadata
11625 var
11626 vkSetHdrMetadataEXT*: proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR, pMetadata: ptr VkHdrMetadataEXT): void {.stdcall.}
11627 proc loadVK_EXT_hdr_metadata*(instance: VkInstance) =
11628 loadVK_KHR_swapchain(instance)
11629 vkSetHdrMetadataEXT = cast[proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR, pMetadata: ptr VkHdrMetadataEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetHdrMetadataEXT"))
11630
11631 proc loadVK_KHR_present_id*(instance: VkInstance) =
11632 loadVK_KHR_swapchain(instance)
11633 loadVK_VERSION_1_1(instance)
11634
11635 # extension VK_KHR_ray_tracing_maintenance1
11636 var
11637 vkCmdTraceRaysIndirect2KHR*: proc(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.}
11638 proc loadVK_KHR_ray_tracing_maintenance1*(instance: VkInstance) =
11639 loadVK_KHR_acceleration_structure(instance)
11640 vkCmdTraceRaysIndirect2KHR = cast[proc(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdTraceRaysIndirect2KHR"))
11641
11642 # extension VK_KHR_ray_tracing_pipeline
11643 var
11644 vkCmdTraceRaysKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, width: uint32, height: uint32, depth: uint32): void {.stdcall.}
11645 vkCreateRayTracingPipelinesKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}
11646 vkGetRayTracingShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}
11647 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}
11648 vkCmdTraceRaysIndirectKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.}
11649 vkGetRayTracingShaderGroupStackSizeKHR*: proc(device: VkDevice, pipeline: VkPipeline, group: uint32, groupShader: VkShaderGroupShaderKHR): VkDeviceSize {.stdcall.}
11650 vkCmdSetRayTracingPipelineStackSizeKHR*: proc(commandBuffer: VkCommandBuffer, pipelineStackSize: uint32): void {.stdcall.}
11651 proc loadVK_KHR_ray_tracing_pipeline*(instance: VkInstance) =
11652 loadVK_VERSION_1_2(instance)
11653 loadVK_KHR_acceleration_structure(instance)
11654 vkCmdTraceRaysKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, width: uint32, height: uint32, depth: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdTraceRaysKHR"))
11655 vkCreateRayTracingPipelinesKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesKHR"))
11656 vkGetRayTracingShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesKHR"))
11657 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))
11658 vkCmdTraceRaysIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdTraceRaysIndirectKHR"))
11659 vkGetRayTracingShaderGroupStackSizeKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, group: uint32, groupShader: VkShaderGroupShaderKHR): VkDeviceSize {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupStackSizeKHR"))
11660 vkCmdSetRayTracingPipelineStackSizeKHR = cast[proc(commandBuffer: VkCommandBuffer, pipelineStackSize: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRayTracingPipelineStackSizeKHR"))
11661
11662 # extension VK_HUAWEI_invocation_mask
11663 var
11664 vkCmdBindInvocationMaskHUAWEI*: proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}
11665 proc loadVK_HUAWEI_invocation_mask*(instance: VkInstance) =
11666 loadVK_KHR_ray_tracing_pipeline(instance)
11667 loadVK_VERSION_1_3(instance)
11668 vkCmdBindInvocationMaskHUAWEI = cast[proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindInvocationMaskHUAWEI"))
11669
11670 # extension VK_EXT_display_surface_counter
11671 var
11672 vkGetPhysicalDeviceSurfaceCapabilities2EXT*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT): VkResult {.stdcall.}
11673 proc loadVK_EXT_display_surface_counter*(instance: VkInstance) =
11674 loadVK_KHR_display(instance)
11675 vkGetPhysicalDeviceSurfaceCapabilities2EXT = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
11676
11677 # extension VK_KHR_get_display_properties2
11678 var
11679 vkGetPhysicalDeviceDisplayProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayProperties2KHR): VkResult {.stdcall.}
11680 vkGetPhysicalDeviceDisplayPlaneProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlaneProperties2KHR): VkResult {.stdcall.}
11681 vkGetDisplayModeProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModeProperties2KHR): VkResult {.stdcall.}
11682 vkGetDisplayPlaneCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR, pCapabilities: ptr VkDisplayPlaneCapabilities2KHR): VkResult {.stdcall.}
11683 proc loadVK_KHR_get_display_properties2*(instance: VkInstance) =
11684 loadVK_KHR_display(instance)
11685 vkGetPhysicalDeviceDisplayProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayProperties2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR"))
11686 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlaneProperties2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
11687 vkGetDisplayModeProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModeProperties2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayModeProperties2KHR"))
11688 vkGetDisplayPlaneCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR, pCapabilities: ptr VkDisplayPlaneCapabilities2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilities2KHR"))
11689
11690 proc loadVK_KHR_ray_query*(instance: VkInstance) =
11691 loadVK_VERSION_1_2(instance)
11692 loadVK_KHR_acceleration_structure(instance)
11693
11694 # extension VK_KHR_display_swapchain
11695 var
11696 vkCreateSharedSwapchainsKHR*: proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchains: ptr VkSwapchainKHR): VkResult {.stdcall.}
11697 proc loadVK_KHR_display_swapchain*(instance: VkInstance) =
11698 loadVK_KHR_swapchain(instance)
11699 loadVK_KHR_display(instance)
11700 vkCreateSharedSwapchainsKHR = cast[proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchains: ptr VkSwapchainKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR"))
11701
11702 # extension VK_EXT_acquire_drm_display
11703 var
11704 vkAcquireDrmDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, drmFd: int32, display: VkDisplayKHR): VkResult {.stdcall.}
11705 vkGetDrmDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, drmFd: int32, connectorId: uint32, display: ptr VkDisplayKHR): VkResult {.stdcall.}
11706 proc loadVK_EXT_acquire_drm_display*(instance: VkInstance) =
11707 loadVK_EXT_direct_mode_display(instance)
11708 vkAcquireDrmDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, drmFd: int32, display: VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT"))
11709 vkGetDrmDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, drmFd: int32, connectorId: uint32, display: ptr VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT"))
11710
11711 # extension VK_EXT_display_control
11712 var
11713 vkDisplayPowerControlEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT): VkResult {.stdcall.}
11714 vkRegisterDeviceEventEXT*: proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}
11715 vkRegisterDisplayEventEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}
11716 vkGetSwapchainCounterEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64): VkResult {.stdcall.}
11717 proc loadVK_EXT_display_control*(instance: VkInstance) =
11718 loadVK_EXT_display_surface_counter(instance)
11719 loadVK_KHR_swapchain(instance)
11720 vkDisplayPowerControlEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDisplayPowerControlEXT"))
11721 vkRegisterDeviceEventEXT = cast[proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkRegisterDeviceEventEXT"))
11722 vkRegisterDisplayEventEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkRegisterDisplayEventEXT"))
11723 vkGetSwapchainCounterEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSwapchainCounterEXT"))
11724
11725 proc loadVK_NV_ray_tracing_motion_blur*(instance: VkInstance) =
11726 loadVK_KHR_ray_tracing_pipeline(instance)
11727
11728 proc loadVK_EXT_pipeline_library_group_handles*(instance: VkInstance) =
11729 loadVK_KHR_ray_tracing_pipeline(instance)
11730 loadVK_KHR_pipeline_library(instance)
11731
11732 # extension VK_NV_ray_tracing
11733 var
11734 vkCreateAccelerationStructureNV*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureNV): VkResult {.stdcall.}
11735 vkDestroyAccelerationStructureNV*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}
11736 vkGetAccelerationStructureMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2KHR): void {.stdcall.}
11737 vkBindAccelerationStructureMemoryNV*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoNV): VkResult {.stdcall.}
11738 vkCmdBuildAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.}
11739 vkCmdCopyAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}
11740 vkCmdTraceRaysNV*: proc(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32, height: uint32, depth: uint32): void {.stdcall.}
11741 vkCreateRayTracingPipelinesNV*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}
11742 vkGetRayTracingShaderGroupHandlesNV*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}
11743 vkGetAccelerationStructureHandleNV*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}
11744 vkCmdWriteAccelerationStructuresPropertiesNV*: proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}
11745 vkCompileDeferredNV*: proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}
11746 proc loadVK_NV_ray_tracing*(instance: VkInstance) =
11747 loadVK_VERSION_1_1(instance)
11748 loadVK_VERSION_1_1(instance)
11749 vkCreateAccelerationStructureNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureNV"))
11750 vkDestroyAccelerationStructureNV = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureNV"))
11751 vkGetAccelerationStructureMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2KHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureMemoryRequirementsNV"))
11752 vkBindAccelerationStructureMemoryNV = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindAccelerationStructureMemoryNV"))
11753 vkCmdBuildAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructureNV"))
11754 vkCmdCopyAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV"))
11755 vkCmdTraceRaysNV = cast[proc(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32, height: uint32, depth: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdTraceRaysNV"))
11756 vkCreateRayTracingPipelinesNV = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV"))
11757 vkGetRayTracingShaderGroupHandlesNV = vkGetRayTracingShaderGroupHandlesKHR
11758 vkGetAccelerationStructureHandleNV = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureHandleNV"))
11759 vkCmdWriteAccelerationStructuresPropertiesNV = cast[proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesNV"))
11760 vkCompileDeferredNV = cast[proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCompileDeferredNV"))
11761
11762 # extension VK_KHR_present_wait
11763 var
11764 vkWaitForPresentKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, presentId: uint64, timeout: uint64): VkResult {.stdcall.}
11765 proc loadVK_KHR_present_wait*(instance: VkInstance) =
11766 loadVK_KHR_swapchain(instance)
11767 loadVK_KHR_present_id(instance)
11768 vkWaitForPresentKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, presentId: uint64, timeout: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWaitForPresentKHR"))
11769
11770 proc loadVK_NV_ray_tracing_invocation_reorder*(instance: VkInstance) =
11771 loadVK_KHR_ray_tracing_pipeline(instance)
11772
11773 var EXTENSION_LOADERS = {
11774 "VK_NV_optical_flow": loadVK_NV_optical_flow,
11775 "VK_EXT_vertex_attribute_divisor": loadVK_EXT_vertex_attribute_divisor,
11776 "VK_EXT_pipeline_library_group_handles": loadVK_EXT_pipeline_library_group_handles,
11777 "VK_NV_geometry_shader_passthrough": loadVK_NV_geometry_shader_passthrough,
11778 "VK_EXT_line_rasterization": loadVK_EXT_line_rasterization,
11779 "VK_EXT_rasterization_order_attachment_access": loadVK_EXT_rasterization_order_attachment_access,
11780 "VK_EXT_shader_atomic_float2": loadVK_EXT_shader_atomic_float2,
11781 "VK_IMG_format_pvrtc": loadVK_IMG_format_pvrtc,
11782 "VK_AMD_texture_gather_bias_lod": loadVK_AMD_texture_gather_bias_lod,
11783 "VK_KHR_shader_subgroup_uniform_control_flow": loadVK_KHR_shader_subgroup_uniform_control_flow,
11784 "VK_AMD_shader_fragment_mask": loadVK_AMD_shader_fragment_mask,
11785 "VK_EXT_external_memory_dma_buf": loadVK_EXT_external_memory_dma_buf,
11786 "VK_IMG_filter_cubic": loadVK_IMG_filter_cubic,
11787 "VK_EXT_pageable_device_local_memory": loadVK_EXT_pageable_device_local_memory,
11788 "VK_EXT_primitive_topology_list_restart": loadVK_EXT_primitive_topology_list_restart,
11789 "VK_KHR_global_priority": loadVK_KHR_global_priority,
11790 "VK_AMD_shader_ballot": loadVK_AMD_shader_ballot,
11791 "VK_AMD_buffer_marker": loadVK_AMD_buffer_marker,
11792 "VK_NV_corner_sampled_image": loadVK_NV_corner_sampled_image,
11793 "VK_NV_ray_tracing_invocation_reorder": loadVK_NV_ray_tracing_invocation_reorder,
11794 "VK_QCOM_image_processing": loadVK_QCOM_image_processing,
11795 "VK_AMD_shader_info": loadVK_AMD_shader_info,
11796 "VK_KHR_pipeline_library": loadVK_KHR_pipeline_library,
11797 "VK_EXT_blend_operation_advanced": loadVK_EXT_blend_operation_advanced,
11798 "VK_AMD_gpu_shader_int16": loadVK_AMD_gpu_shader_int16,
11799 "VK_EXT_pipeline_robustness": loadVK_EXT_pipeline_robustness,
11800 "VK_NV_scissor_exclusive": loadVK_NV_scissor_exclusive,
11801 "VK_EXT_sample_locations": loadVK_EXT_sample_locations,
11802 "VK_NV_framebuffer_mixed_samples": loadVK_NV_framebuffer_mixed_samples,
11803 "VK_NV_sample_mask_override_coverage": loadVK_NV_sample_mask_override_coverage,
11804 "VK_KHR_present_id": loadVK_KHR_present_id,
11805 "VK_EXT_descriptor_buffer": loadVK_EXT_descriptor_buffer,
11806 "VK_EXT_filter_cubic": loadVK_EXT_filter_cubic,
11807 "VK_KHR_pipeline_executable_properties": loadVK_KHR_pipeline_executable_properties,
11808 "VK_EXT_extended_dynamic_state3": loadVK_EXT_extended_dynamic_state3,
11809 "VK_KHR_performance_query": loadVK_KHR_performance_query,
11810 "VK_GOOGLE_user_type": loadVK_GOOGLE_user_type,
11811 "VK_KHR_ray_tracing_maintenance1": loadVK_KHR_ray_tracing_maintenance1,
11812 "VK_EXT_debug_report": loadVK_EXT_debug_report,
11813 "VK_EXT_multisampled_render_to_single_sampled": loadVK_EXT_multisampled_render_to_single_sampled,
11814 "VK_EXT_device_address_binding_report": loadVK_EXT_device_address_binding_report,
11815 "VK_NV_clip_space_w_scaling": loadVK_NV_clip_space_w_scaling,
11816 "VK_NV_fill_rectangle": loadVK_NV_fill_rectangle,
11817 "VK_EXT_shader_image_atomic_int64": loadVK_EXT_shader_image_atomic_int64,
11818 "VK_KHR_swapchain": loadVK_KHR_swapchain,
11819 "VK_NV_ray_tracing": loadVK_NV_ray_tracing,
11820 "VK_EXT_swapchain_maintenance1": loadVK_EXT_swapchain_maintenance1,
11821 "VK_KHR_ray_tracing_pipeline": loadVK_KHR_ray_tracing_pipeline,
11822 "VK_EXT_ycbcr_image_arrays": loadVK_EXT_ycbcr_image_arrays,
11823 "VK_AMD_negative_viewport_height": loadVK_AMD_negative_viewport_height,
11824 "VK_EXT_provoking_vertex": loadVK_EXT_provoking_vertex,
11825 "VK_EXT_calibrated_timestamps": loadVK_EXT_calibrated_timestamps,
11826 "VK_EXT_attachment_feedback_loop_layout": loadVK_EXT_attachment_feedback_loop_layout,
11827 "VK_AMD_mixed_attachment_samples": loadVK_AMD_mixed_attachment_samples,
11828 "VK_HUAWEI_invocation_mask": loadVK_HUAWEI_invocation_mask,
11829 "VK_EXT_external_memory_host": loadVK_EXT_external_memory_host,
11830 "VK_NV_device_diagnostics_config": loadVK_NV_device_diagnostics_config,
11831 "VK_EXT_fragment_density_map2": loadVK_EXT_fragment_density_map2,
11832 "VK_NV_shader_subgroup_partitioned": loadVK_NV_shader_subgroup_partitioned,
11833 "VK_EXT_image_sliced_view_of_3d": loadVK_EXT_image_sliced_view_of_3d,
11834 "VK_NV_fragment_shading_rate_enums": loadVK_NV_fragment_shading_rate_enums,
11835 "VK_EXT_display_surface_counter": loadVK_EXT_display_surface_counter,
11836 "VK_ARM_shader_core_properties": loadVK_ARM_shader_core_properties,
11837 "VK_EXT_shader_module_identifier": loadVK_EXT_shader_module_identifier,
11838 "VK_EXT_border_color_swizzle": loadVK_EXT_border_color_swizzle,
11839 "VK_AMD_shader_image_load_store_lod": loadVK_AMD_shader_image_load_store_lod,
11840 "VK_AMD_display_native_hdr": loadVK_AMD_display_native_hdr,
11841 "VK_NV_memory_decompression": loadVK_NV_memory_decompression,
11842 "VK_EXT_direct_mode_display": loadVK_EXT_direct_mode_display,
11843 "VK_EXT_fragment_shader_interlock": loadVK_EXT_fragment_shader_interlock,
11844 "VK_NV_coverage_reduction_mode": loadVK_NV_coverage_reduction_mode,
11845 "VK_KHR_get_display_properties2": loadVK_KHR_get_display_properties2,
11846 "VK_INTEL_shader_integer_functions2": loadVK_INTEL_shader_integer_functions2,
11847 "VK_NV_glsl_shader": loadVK_NV_glsl_shader,
11848 "VK_KHR_shader_clock": loadVK_KHR_shader_clock,
11849 "VK_EXT_image_2d_view_of_3d": loadVK_EXT_image_2d_view_of_3d,
11850 "VK_QCOM_tile_properties": loadVK_QCOM_tile_properties,
11851 "VK_KHR_push_descriptor": loadVK_KHR_push_descriptor,
11852 "VK_NV_viewport_swizzle": loadVK_NV_viewport_swizzle,
11853 "VK_KHR_ray_query": loadVK_KHR_ray_query,
11854 "VK_KHR_present_wait": loadVK_KHR_present_wait,
11855 "VK_NV_shading_rate_image": loadVK_NV_shading_rate_image,
11856 "VK_EXT_fragment_density_map": loadVK_EXT_fragment_density_map,
11857 "VK_NV_device_diagnostic_checkpoints": loadVK_NV_device_diagnostic_checkpoints,
11858 "VK_EXT_pci_bus_info": loadVK_EXT_pci_bus_info,
11859 "VK_NV_external_memory": loadVK_NV_external_memory,
11860 "VK_EXT_queue_family_foreign": loadVK_EXT_queue_family_foreign,
11861 "VK_KHR_swapchain_mutable_format": loadVK_KHR_swapchain_mutable_format,
11862 "VK_EXT_depth_clip_control": loadVK_EXT_depth_clip_control,
11863 "VK_EXT_debug_utils": loadVK_EXT_debug_utils,
11864 "VK_KHR_portability_enumeration": loadVK_KHR_portability_enumeration,
11865 "VK_EXT_memory_priority": loadVK_EXT_memory_priority,
11866 "VK_EXT_validation_flags": loadVK_EXT_validation_flags,
11867 "VK_AMD_shader_core_properties": loadVK_AMD_shader_core_properties,
11868 "VK_EXT_conservative_rasterization": loadVK_EXT_conservative_rasterization,
11869 "VK_KHR_external_fence_fd": loadVK_KHR_external_fence_fd,
11870 "VK_NV_device_generated_commands": loadVK_NV_device_generated_commands,
11871 "VK_NV_present_barrier": loadVK_NV_present_barrier,
11872 "VK_AMD_gcn_shader": loadVK_AMD_gcn_shader,
11873 "VK_NV_viewport_array2": loadVK_NV_viewport_array2,
11874 "VK_INTEL_performance_query": loadVK_INTEL_performance_query,
11875 "VK_NVX_multiview_per_view_attributes": loadVK_NVX_multiview_per_view_attributes,
11876 "VK_EXT_primitives_generated_query": loadVK_EXT_primitives_generated_query,
11877 "VK_AMD_pipeline_compiler_control": loadVK_AMD_pipeline_compiler_control,
11878 "VK_EXT_post_depth_coverage": loadVK_EXT_post_depth_coverage,
11879 "VK_EXT_rgba10x6_formats": loadVK_EXT_rgba10x6_formats,
11880 "VK_KHR_external_memory_fd": loadVK_KHR_external_memory_fd,
11881 "VK_NV_dedicated_allocation_image_aliasing": loadVK_NV_dedicated_allocation_image_aliasing,
11882 "VK_NV_cooperative_matrix": loadVK_NV_cooperative_matrix,
11883 "VK_EXT_depth_clamp_zero_one": loadVK_EXT_depth_clamp_zero_one,
11884 "VK_EXT_conditional_rendering": loadVK_EXT_conditional_rendering,
11885 "VK_QCOM_multiview_per_view_viewports": loadVK_QCOM_multiview_per_view_viewports,
11886 "VK_NV_linear_color_attachment": loadVK_NV_linear_color_attachment,
11887 "VK_EXT_shader_subgroup_ballot": loadVK_EXT_shader_subgroup_ballot,
11888 "VK_EXT_multi_draw": loadVK_EXT_multi_draw,
11889 "VK_NV_fragment_coverage_to_color": loadVK_NV_fragment_coverage_to_color,
11890 "VK_EXT_load_store_op_none": loadVK_EXT_load_store_op_none,
11891 "VK_QCOM_rotated_copy_commands": loadVK_QCOM_rotated_copy_commands,
11892 "VK_EXT_surface_maintenance1": loadVK_EXT_surface_maintenance1,
11893 "VK_EXT_swapchain_colorspace": loadVK_EXT_swapchain_colorspace,
11894 "VK_EXT_image_drm_format_modifier": loadVK_EXT_image_drm_format_modifier,
11895 "VK_EXT_validation_features": loadVK_EXT_validation_features,
11896 "VK_KHR_workgroup_memory_explicit_layout": loadVK_KHR_workgroup_memory_explicit_layout,
11897 "VK_EXT_index_type_uint8": loadVK_EXT_index_type_uint8,
11898 "VK_EXT_mesh_shader": loadVK_EXT_mesh_shader,
11899 "VK_AMD_shader_early_and_late_fragment_tests": loadVK_AMD_shader_early_and_late_fragment_tests,
11900 "VK_KHR_display_swapchain": loadVK_KHR_display_swapchain,
11901 "VK_EXT_transform_feedback": loadVK_EXT_transform_feedback,
11902 "VK_GOOGLE_decorate_string": loadVK_GOOGLE_decorate_string,
11903 "VK_EXT_shader_atomic_float": loadVK_EXT_shader_atomic_float,
11904 "VK_EXT_acquire_drm_display": loadVK_EXT_acquire_drm_display,
11905 "VK_EXT_pipeline_properties": loadVK_EXT_pipeline_properties,
11906 "VK_EXT_graphics_pipeline_library": loadVK_EXT_graphics_pipeline_library,
11907 "VK_KHR_acceleration_structure": loadVK_KHR_acceleration_structure,
11908 "VK_AMD_shader_core_properties2": loadVK_AMD_shader_core_properties2,
11909 "VK_KHR_surface": loadVK_KHR_surface,
11910 "VK_AMD_gpu_shader_half_float": loadVK_AMD_gpu_shader_half_float,
11911 "VK_KHR_deferred_host_operations": loadVK_KHR_deferred_host_operations,
11912 "VK_NV_dedicated_allocation": loadVK_NV_dedicated_allocation,
11913 "VK_GOOGLE_hlsl_functionality1": loadVK_GOOGLE_hlsl_functionality1,
11914 "VK_EXT_robustness2": loadVK_EXT_robustness2,
11915 "VK_NVX_image_view_handle": loadVK_NVX_image_view_handle,
11916 "VK_EXT_non_seamless_cube_map": loadVK_EXT_non_seamless_cube_map,
11917 "VK_EXT_opacity_micromap": loadVK_EXT_opacity_micromap,
11918 "VK_EXT_image_view_min_lod": loadVK_EXT_image_view_min_lod,
11919 "VK_AMD_shader_trinary_minmax": loadVK_AMD_shader_trinary_minmax,
11920 "VK_QCOM_render_pass_store_ops": loadVK_QCOM_render_pass_store_ops,
11921 "VK_EXT_device_fault": loadVK_EXT_device_fault,
11922 "VK_EXT_custom_border_color": loadVK_EXT_custom_border_color,
11923 "VK_EXT_mutable_descriptor_type": loadVK_EXT_mutable_descriptor_type,
11924 "VK_AMD_rasterization_order": loadVK_AMD_rasterization_order,
11925 "VK_EXT_vertex_input_dynamic_state": loadVK_EXT_vertex_input_dynamic_state,
11926 "VK_KHR_incremental_present": loadVK_KHR_incremental_present,
11927 "VK_KHR_fragment_shading_rate": loadVK_KHR_fragment_shading_rate,
11928 "VK_EXT_color_write_enable": loadVK_EXT_color_write_enable,
11929 "VK_SEC_amigo_profiling": loadVK_SEC_amigo_profiling,
11930 "VK_GOOGLE_display_timing": loadVK_GOOGLE_display_timing,
11931 "VK_NVX_binary_import": loadVK_NVX_binary_import,
11932 "VK_EXT_depth_clip_enable": loadVK_EXT_depth_clip_enable,
11933 "VK_EXT_subpass_merge_feedback": loadVK_EXT_subpass_merge_feedback,
11934 "VK_NV_representative_fragment_test": loadVK_NV_representative_fragment_test,
11935 "VK_EXT_validation_cache": loadVK_EXT_validation_cache,
11936 "VK_EXT_display_control": loadVK_EXT_display_control,
11937 "VK_KHR_external_semaphore_fd": loadVK_KHR_external_semaphore_fd,
11938 "VK_KHR_fragment_shader_barycentric": loadVK_KHR_fragment_shader_barycentric,
11939 "VK_NV_inherited_viewport_scissor": loadVK_NV_inherited_viewport_scissor,
11940 "VK_EXT_legacy_dithering": loadVK_EXT_legacy_dithering,
11941 "VK_NV_ray_tracing_motion_blur": loadVK_NV_ray_tracing_motion_blur,
11942 "VK_EXT_physical_device_drm": loadVK_EXT_physical_device_drm,
11943 "VK_EXT_pipeline_protected_access": loadVK_EXT_pipeline_protected_access,
11944 "VK_QCOM_render_pass_transform": loadVK_QCOM_render_pass_transform,
11945 "VK_GOOGLE_surfaceless_query": loadVK_GOOGLE_surfaceless_query,
11946 "VK_EXT_memory_budget": loadVK_EXT_memory_budget,
11947 "VK_EXT_discard_rectangles": loadVK_EXT_discard_rectangles,
11948 "VK_EXT_shader_stencil_export": loadVK_EXT_shader_stencil_export,
11949 "VK_KHR_shared_presentable_image": loadVK_KHR_shared_presentable_image,
11950 "VK_NV_external_memory_rdma": loadVK_NV_external_memory_rdma,
11951 "VK_EXT_image_compression_control_swapchain": loadVK_EXT_image_compression_control_swapchain,
11952 "VK_EXT_hdr_metadata": loadVK_EXT_hdr_metadata,
11953 "VK_AMD_device_coherent_memory": loadVK_AMD_device_coherent_memory,
11954 "VK_EXT_device_memory_report": loadVK_EXT_device_memory_report,
11955 "VK_ARM_shader_core_builtins": loadVK_ARM_shader_core_builtins,
11956 "VK_QCOM_multiview_per_view_render_areas": loadVK_QCOM_multiview_per_view_render_areas,
11957 "VK_LUNARG_direct_driver_loading": loadVK_LUNARG_direct_driver_loading,
11958 "VK_AMD_memory_overallocation_behavior": loadVK_AMD_memory_overallocation_behavior,
11959 "VK_NV_mesh_shader": loadVK_NV_mesh_shader,
11960 "VK_AMD_shader_explicit_vertex_parameter": loadVK_AMD_shader_explicit_vertex_parameter,
11961 "VK_EXT_headless_surface": loadVK_EXT_headless_surface,
11962 "VK_NV_shader_sm_builtins": loadVK_NV_shader_sm_builtins,
11963 "VK_EXT_shader_subgroup_vote": loadVK_EXT_shader_subgroup_vote,
11964 "VK_NV_copy_memory_indirect": loadVK_NV_copy_memory_indirect,
11965 "VK_EXT_image_compression_control": loadVK_EXT_image_compression_control,
11966 "VK_EXT_astc_decode_mode": loadVK_EXT_astc_decode_mode,
11967 "VK_EXT_buffer_device_address": loadVK_EXT_buffer_device_address,
11968 "VK_KHR_get_surface_capabilities2": loadVK_KHR_get_surface_capabilities2,
11969 "VK_KHR_display": loadVK_KHR_display,
11970 "VK_QCOM_render_pass_shader_resolve": loadVK_QCOM_render_pass_shader_resolve,
11971 "VK_EXT_depth_range_unrestricted": loadVK_EXT_depth_range_unrestricted,
11972 "VK_HUAWEI_subpass_shading": loadVK_HUAWEI_subpass_shading,
11973 "VK_VALVE_descriptor_set_host_mapping": loadVK_VALVE_descriptor_set_host_mapping,
11974 "VK_HUAWEI_cluster_culling_shader": loadVK_HUAWEI_cluster_culling_shader,
11975 "VK_KHR_surface_protected_capabilities": loadVK_KHR_surface_protected_capabilities,
11976 "VK_NV_shader_image_footprint": loadVK_NV_shader_image_footprint,
11977 "VK_NV_external_memory_capabilities": loadVK_NV_external_memory_capabilities,
11978 "VK_NV_compute_shader_derivatives": loadVK_NV_compute_shader_derivatives,
11979 "VK_QCOM_fragment_density_map_offset": loadVK_QCOM_fragment_density_map_offset,
11980 }.toTable
11981 when defined(VK_USE_PLATFORM_XLIB_KHR):
11982 include ./platform/xlib
11983 EXTENSION_LOADERS["VK_KHR_xlib_surface"] = loadVK_KHR_xlib_surface
11984 when defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT):
11985 include ./platform/xlib_xrandr
11986 EXTENSION_LOADERS["VK_EXT_acquire_xlib_display"] = loadVK_EXT_acquire_xlib_display
11987 when defined(VK_USE_PLATFORM_XCB_KHR):
11988 include ./platform/xcb
11989 EXTENSION_LOADERS["VK_KHR_xcb_surface"] = loadVK_KHR_xcb_surface
11990 when defined(VK_USE_PLATFORM_WAYLAND_KHR):
11991 include ./platform/wayland
11992 EXTENSION_LOADERS["VK_KHR_wayland_surface"] = loadVK_KHR_wayland_surface
11993 when defined(VK_USE_PLATFORM_DIRECTFB_EXT):
11994 include ./platform/directfb
11995 EXTENSION_LOADERS["VK_EXT_directfb_surface"] = loadVK_EXT_directfb_surface
11996 when defined(VK_USE_PLATFORM_ANDROID_KHR):
11997 include ./platform/android
11998 EXTENSION_LOADERS["VK_KHR_android_surface"] = loadVK_KHR_android_surface
11999 EXTENSION_LOADERS["VK_ANDROID_external_memory_android_hardware_buffer"] = loadVK_ANDROID_external_memory_android_hardware_buffer
12000 when defined(VK_USE_PLATFORM_WIN32_KHR):
12001 include ./platform/win32
12002 EXTENSION_LOADERS["VK_KHR_external_semaphore_win32"] = loadVK_KHR_external_semaphore_win32
12003 EXTENSION_LOADERS["VK_EXT_full_screen_exclusive"] = loadVK_EXT_full_screen_exclusive
12004 EXTENSION_LOADERS["VK_NV_external_memory_win32"] = loadVK_NV_external_memory_win32
12005 EXTENSION_LOADERS["VK_KHR_external_memory_win32"] = loadVK_KHR_external_memory_win32
12006 EXTENSION_LOADERS["VK_NV_acquire_winrt_display"] = loadVK_NV_acquire_winrt_display
12007 EXTENSION_LOADERS["VK_KHR_win32_surface"] = loadVK_KHR_win32_surface
12008 EXTENSION_LOADERS["VK_KHR_external_fence_win32"] = loadVK_KHR_external_fence_win32
12009 EXTENSION_LOADERS["VK_KHR_win32_keyed_mutex"] = loadVK_KHR_win32_keyed_mutex
12010 when defined(VK_USE_PLATFORM_VI_NN):
12011 include ./platform/vi
12012 EXTENSION_LOADERS["VK_NN_vi_surface"] = loadVK_NN_vi_surface
12013 when defined(VK_USE_PLATFORM_IOS_MVK):
12014 include ./platform/ios
12015 EXTENSION_LOADERS["VK_MVK_ios_surface"] = loadVK_MVK_ios_surface
12016 when defined(VK_USE_PLATFORM_MACOS_MVK):
12017 include ./platform/macos
12018 EXTENSION_LOADERS["VK_MVK_macos_surface"] = loadVK_MVK_macos_surface
12019 when defined(VK_USE_PLATFORM_METAL_EXT):
12020 include ./platform/metal
12021 EXTENSION_LOADERS["VK_EXT_metal_objects"] = loadVK_EXT_metal_objects
12022 EXTENSION_LOADERS["VK_EXT_metal_surface"] = loadVK_EXT_metal_surface
12023 when defined(VK_USE_PLATFORM_FUCHSIA):
12024 include ./platform/fuchsia
12025 EXTENSION_LOADERS["VK_FUCHSIA_external_semaphore"] = loadVK_FUCHSIA_external_semaphore
12026 EXTENSION_LOADERS["VK_FUCHSIA_imagepipe_surface"] = loadVK_FUCHSIA_imagepipe_surface
12027 EXTENSION_LOADERS["VK_FUCHSIA_external_memory"] = loadVK_FUCHSIA_external_memory
12028 EXTENSION_LOADERS["VK_FUCHSIA_buffer_collection"] = loadVK_FUCHSIA_buffer_collection
12029 when defined(VK_USE_PLATFORM_GGP):
12030 include ./platform/ggp
12031 EXTENSION_LOADERS["VK_GGP_frame_token"] = loadVK_GGP_frame_token
12032 EXTENSION_LOADERS["VK_GGP_stream_descriptor_surface"] = loadVK_GGP_stream_descriptor_surface
12033 when defined(VK_USE_PLATFORM_SCI):
12034 include ./platform/sci
12035 when defined(VK_ENABLE_BETA_EXTENSIONS):
12036 include ./platform/provisional
12037 EXTENSION_LOADERS["VK_KHR_video_encode_queue"] = loadVK_KHR_video_encode_queue
12038 EXTENSION_LOADERS["VK_KHR_video_queue"] = loadVK_KHR_video_queue
12039 EXTENSION_LOADERS["VK_EXT_video_encode_h264"] = loadVK_EXT_video_encode_h264
12040 EXTENSION_LOADERS["VK_EXT_video_encode_h265"] = loadVK_EXT_video_encode_h265
12041 EXTENSION_LOADERS["VK_KHR_video_decode_queue"] = loadVK_KHR_video_decode_queue
12042 EXTENSION_LOADERS["VK_KHR_video_decode_h264"] = loadVK_KHR_video_decode_h264
12043 EXTENSION_LOADERS["VK_KHR_portability_subset"] = loadVK_KHR_portability_subset
12044 EXTENSION_LOADERS["VK_KHR_video_decode_h265"] = loadVK_KHR_video_decode_h265
12045 when defined(VK_USE_PLATFORM_SCREEN_QNX):
12046 include ./platform/screen
12047 EXTENSION_LOADERS["VK_QNX_screen_surface"] = loadVK_QNX_screen_surface
12048
12049 proc loadExtension*(instance: VkInstance, extension: string) =
12050 if extension in EXTENSION_LOADERS:
12051 EXTENSION_LOADERS[extension](instance)
12052
12053 # load global functions immediately
12054 block globalFunctions:
12055 let instance = VkInstance(0)
12056 vkEnumerateInstanceVersion = cast[proc(pApiVersion: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceVersion"))
12057 vkEnumerateInstanceExtensionProperties = cast[proc(pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceExtensionProperties"))
12058 vkEnumerateInstanceLayerProperties = cast[proc(pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceLayerProperties"))
12059 vkCreateInstance = cast[proc(pCreateInfo: ptr VkInstanceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pInstance: ptr VkInstance): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateInstance"))
12060
12061 converter NimBool2VkBool*(a: bool): VkBool32 = VkBool32(a)