|
1199
|
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_WIN32_KHR):
|
|
|
11985 include ./platform/win32
|
|
|
11986 EXTENSION_LOADERS["VK_KHR_external_semaphore_win32"] = loadVK_KHR_external_semaphore_win32
|
|
|
11987 EXTENSION_LOADERS["VK_EXT_full_screen_exclusive"] = loadVK_EXT_full_screen_exclusive
|
|
|
11988 EXTENSION_LOADERS["VK_NV_external_memory_win32"] = loadVK_NV_external_memory_win32
|
|
|
11989 EXTENSION_LOADERS["VK_KHR_external_memory_win32"] = loadVK_KHR_external_memory_win32
|
|
|
11990 EXTENSION_LOADERS["VK_NV_acquire_winrt_display"] = loadVK_NV_acquire_winrt_display
|
|
|
11991 EXTENSION_LOADERS["VK_KHR_win32_surface"] = loadVK_KHR_win32_surface
|
|
|
11992 EXTENSION_LOADERS["VK_KHR_external_fence_win32"] = loadVK_KHR_external_fence_win32
|
|
|
11993 EXTENSION_LOADERS["VK_KHR_win32_keyed_mutex"] = loadVK_KHR_win32_keyed_mutex
|
|
|
11994
|
|
|
11995 proc loadExtension*(instance: VkInstance, extension: string) =
|
|
|
11996 if extension in EXTENSION_LOADERS:
|
|
|
11997 EXTENSION_LOADERS[extension](instance)
|
|
|
11998
|
|
|
11999 # load global functions immediately
|
|
|
12000 block globalFunctions:
|
|
|
12001 let instance = VkInstance(0)
|
|
|
12002 vkEnumerateInstanceVersion = cast[proc(pApiVersion: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceVersion"))
|
|
|
12003 vkEnumerateInstanceExtensionProperties = cast[proc(pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceExtensionProperties"))
|
|
|
12004 vkEnumerateInstanceLayerProperties = cast[proc(pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceLayerProperties"))
|
|
|
12005 vkCreateInstance = cast[proc(pCreateInfo: ptr VkInstanceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pInstance: ptr VkInstance): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateInstance"))
|
|
|
12006
|
|
|
12007 converter NimBool2VkBool*(a: bool): VkBool32 = VkBool32(a)
|
