Mercurial > games > semicongine
comparison semiconginev2/old/core/vulkanapi.nim @ 1218:56781cc0fc7c compiletime-tests
did: renamge main package
| author | sam <sam@basx.dev> |
|---|---|
| date | Wed, 17 Jul 2024 21:01:37 +0700 |
| parents | semicongine/old/core/vulkanapi.nim@a3eb305bcac2 |
| children |
comparison
equal
deleted
inserted
replaced
| 1217:f819a874058f | 1218:56781cc0fc7c |
|---|---|
| 1 import std/dynlib | |
| 2 import std/tables | |
| 3 import std/strutils | |
| 4 import std/logging | |
| 5 import std/typetraits | |
| 6 import std/macros | |
| 7 type | |
| 8 VkHandle* = distinct uint | |
| 9 VkNonDispatchableHandle* = distinct uint | |
| 10 when defined(linux): | |
| 11 let vulkanLib* = loadLib("libvulkan.so.1") | |
| 12 when defined(windows): | |
| 13 let vulkanLib* = loadLib("vulkan-1.dll") | |
| 14 if vulkanLib == nil: | |
| 15 raise newException(Exception, "Unable to load vulkan library") | |
| 16 func VK_MAKE_API_VERSION*(variant: uint32, major: uint32, minor: uint32, patch: uint32): uint32 {.compileTime.} = | |
| 17 (variant shl 29) or (major shl 22) or (minor shl 12) or patch | |
| 18 | |
| 19 template checkVkResult*(call: untyped) = | |
| 20 when defined(release): | |
| 21 discard call | |
| 22 else: | |
| 23 # yes, a bit cheap, but this is only for nice debug output | |
| 24 var callstr = astToStr(call).replace("\n", "") | |
| 25 while callstr.find(" ") >= 0: | |
| 26 callstr = callstr.replace(" ", " ") | |
| 27 debug "Calling vulkan: ", callstr | |
| 28 let value = call | |
| 29 if value != VK_SUCCESS: | |
| 30 error "Vulkan error: ", astToStr(call), " returned ", $value | |
| 31 raise newException(Exception, "Vulkan error: " & astToStr(call) & | |
| 32 " returned " & $value) | |
| 33 # custom enum iteration (for enum values > 2^16) | |
| 34 macro enumFullRange(a: typed): untyped = | |
| 35 newNimNode(nnkBracket).add(a.getType[1][1..^1]) | |
| 36 | |
| 37 iterator items*[T: HoleyEnum](E: typedesc[T]): T = | |
| 38 for a in enumFullRange(E): yield a | |
| 39 const | |
| 40 VK_MAX_PHYSICAL_DEVICE_NAME_SIZE*: uint32 = 256 | |
| 41 VK_UUID_SIZE*: uint32 = 16 | |
| 42 VK_LUID_SIZE*: uint32 = 8 | |
| 43 VK_LUID_SIZE_KHR* = VK_LUID_SIZE | |
| 44 VK_MAX_EXTENSION_NAME_SIZE*: uint32 = 256 | |
| 45 VK_MAX_DESCRIPTION_SIZE*: uint32 = 256 | |
| 46 VK_MAX_MEMORY_TYPES*: uint32 = 32 | |
| 47 VK_MAX_MEMORY_HEAPS*: uint32 = 16 | |
| 48 VK_LOD_CLAMP_NONE*: float32 = 1000.0F | |
| 49 VK_REMAINING_MIP_LEVELS*: uint32 = not 0'u32 | |
| 50 VK_REMAINING_ARRAY_LAYERS*: uint32 = not 0'u32 | |
| 51 VK_REMAINING_3D_SLICES_EXT*: uint32 = not 0'u32 | |
| 52 VK_WHOLE_SIZE*: uint64 = not 0'u64 | |
| 53 VK_ATTACHMENT_UNUSED*: uint32 = not 0'u32 | |
| 54 VK_TRUE*: uint32 = 1 | |
| 55 VK_FALSE*: uint32 = 0 | |
| 56 VK_QUEUE_FAMILY_IGNORED*: uint32 = not 0'u32 | |
| 57 VK_QUEUE_FAMILY_EXTERNAL*: uint32 = not 1'u32 | |
| 58 VK_QUEUE_FAMILY_EXTERNAL_KHR* = VK_QUEUE_FAMILY_EXTERNAL | |
| 59 VK_QUEUE_FAMILY_FOREIGN_EXT*: uint32 = not 2'u32 | |
| 60 VK_SUBPASS_EXTERNAL*: uint32 = not 0'u32 | |
| 61 VK_MAX_DEVICE_GROUP_SIZE*: uint32 = 32 | |
| 62 VK_MAX_DEVICE_GROUP_SIZE_KHR* = VK_MAX_DEVICE_GROUP_SIZE | |
| 63 VK_MAX_DRIVER_NAME_SIZE*: uint32 = 256 | |
| 64 VK_MAX_DRIVER_NAME_SIZE_KHR* = VK_MAX_DRIVER_NAME_SIZE | |
| 65 VK_MAX_DRIVER_INFO_SIZE*: uint32 = 256 | |
| 66 VK_MAX_DRIVER_INFO_SIZE_KHR* = VK_MAX_DRIVER_INFO_SIZE | |
| 67 VK_SHADER_UNUSED_KHR*: uint32 = not 0'u32 | |
| 68 VK_SHADER_UNUSED_NV* = VK_SHADER_UNUSED_KHR | |
| 69 VK_MAX_GLOBAL_PRIORITY_SIZE_KHR*: uint32 = 16 | |
| 70 VK_MAX_GLOBAL_PRIORITY_SIZE_EXT* = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR | |
| 71 VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT*: uint32 = 32 | |
| 72 type | |
| 73 ANativeWindow* = object | |
| 74 AHardwareBuffer* = object | |
| 75 CAMetalLayer* = object | |
| 76 MTLDevice_id* = object | |
| 77 MTLCommandQueue_id* = object | |
| 78 MTLBuffer_id* = object | |
| 79 MTLTexture_id* = object | |
| 80 MTLSharedEvent_id* = object | |
| 81 IOSurfaceRef* = object | |
| 82 VkSampleMask* = uint32 | |
| 83 VkBool32* = uint32 | |
| 84 VkFlags* = uint32 | |
| 85 VkFlags64* = uint64 | |
| 86 VkDeviceSize* = uint64 | |
| 87 VkDeviceAddress* = uint64 | |
| 88 VkInstance* = distinct VkHandle | |
| 89 VkPhysicalDevice* = distinct VkHandle | |
| 90 VkDevice* = distinct VkHandle | |
| 91 VkQueue* = distinct VkHandle | |
| 92 VkCommandBuffer* = distinct VkHandle | |
| 93 VkDeviceMemory* = distinct VkNonDispatchableHandle | |
| 94 VkCommandPool* = distinct VkNonDispatchableHandle | |
| 95 VkBuffer* = distinct VkNonDispatchableHandle | |
| 96 VkBufferView* = distinct VkNonDispatchableHandle | |
| 97 VkImage* = distinct VkNonDispatchableHandle | |
| 98 VkImageView* = distinct VkNonDispatchableHandle | |
| 99 VkShaderModule* = distinct VkNonDispatchableHandle | |
| 100 VkPipeline* = distinct VkNonDispatchableHandle | |
| 101 VkPipelineLayout* = distinct VkNonDispatchableHandle | |
| 102 VkSampler* = distinct VkNonDispatchableHandle | |
| 103 VkDescriptorSet* = distinct VkNonDispatchableHandle | |
| 104 VkDescriptorSetLayout* = distinct VkNonDispatchableHandle | |
| 105 VkDescriptorPool* = distinct VkNonDispatchableHandle | |
| 106 VkFence* = distinct VkNonDispatchableHandle | |
| 107 VkSemaphore* = distinct VkNonDispatchableHandle | |
| 108 VkEvent* = distinct VkNonDispatchableHandle | |
| 109 VkQueryPool* = distinct VkNonDispatchableHandle | |
| 110 VkFramebuffer* = distinct VkNonDispatchableHandle | |
| 111 VkRenderPass* = distinct VkNonDispatchableHandle | |
| 112 VkPipelineCache* = distinct VkNonDispatchableHandle | |
| 113 VkIndirectCommandsLayoutNV* = distinct VkNonDispatchableHandle | |
| 114 VkDescriptorUpdateTemplate* = distinct VkNonDispatchableHandle | |
| 115 VkSamplerYcbcrConversion* = distinct VkNonDispatchableHandle | |
| 116 VkValidationCacheEXT* = distinct VkNonDispatchableHandle | |
| 117 VkAccelerationStructureKHR* = distinct VkNonDispatchableHandle | |
| 118 VkAccelerationStructureNV* = distinct VkNonDispatchableHandle | |
| 119 VkPerformanceConfigurationINTEL* = distinct VkNonDispatchableHandle | |
| 120 VkBufferCollectionFUCHSIA* = distinct VkNonDispatchableHandle | |
| 121 VkDeferredOperationKHR* = distinct VkNonDispatchableHandle | |
| 122 VkPrivateDataSlot* = distinct VkNonDispatchableHandle | |
| 123 VkCuModuleNVX* = distinct VkNonDispatchableHandle | |
| 124 VkCuFunctionNVX* = distinct VkNonDispatchableHandle | |
| 125 VkOpticalFlowSessionNV* = distinct VkNonDispatchableHandle | |
| 126 VkMicromapEXT* = distinct VkNonDispatchableHandle | |
| 127 VkDisplayKHR* = distinct VkNonDispatchableHandle | |
| 128 VkDisplayModeKHR* = distinct VkNonDispatchableHandle | |
| 129 VkSurfaceKHR* = distinct VkNonDispatchableHandle | |
| 130 VkSwapchainKHR* = distinct VkNonDispatchableHandle | |
| 131 VkDebugReportCallbackEXT* = distinct VkNonDispatchableHandle | |
| 132 VkDebugUtilsMessengerEXT* = distinct VkNonDispatchableHandle | |
| 133 VkVideoSessionKHR* = distinct VkNonDispatchableHandle | |
| 134 VkVideoSessionParametersKHR* = distinct VkNonDispatchableHandle | |
| 135 VkSemaphoreSciSyncPoolNV* = distinct VkNonDispatchableHandle | |
| 136 VkRemoteAddressNV* = pointer | |
| 137 proc `$`*(handle: VkInstance): string = "VkInstance(" & $(uint(handle)) & ")" | |
| 138 proc Valid*(handle: VkInstance): bool = uint(handle) != 0 | |
| 139 proc Reset*(handle: var VkInstance) = handle = VkInstance(0) | |
| 140 proc `==`*(a, b: VkInstance): bool = uint(a) == uint(b) | |
| 141 proc `$`*(handle: VkPhysicalDevice): string = "VkPhysicalDevice(" & $(uint(handle)) & ")" | |
| 142 proc Valid*(handle: VkPhysicalDevice): bool = uint(handle) != 0 | |
| 143 proc Reset*(handle: var VkPhysicalDevice) = handle = VkPhysicalDevice(0) | |
| 144 proc `==`*(a, b: VkPhysicalDevice): bool = uint(a) == uint(b) | |
| 145 proc `$`*(handle: VkDevice): string = "VkDevice(" & $(uint(handle)) & ")" | |
| 146 proc Valid*(handle: VkDevice): bool = uint(handle) != 0 | |
| 147 proc Reset*(handle: var VkDevice) = handle = VkDevice(0) | |
| 148 proc `==`*(a, b: VkDevice): bool = uint(a) == uint(b) | |
| 149 proc `$`*(handle: VkQueue): string = "VkQueue(" & $(uint(handle)) & ")" | |
| 150 proc Valid*(handle: VkQueue): bool = uint(handle) != 0 | |
| 151 proc Reset*(handle: var VkQueue) = handle = VkQueue(0) | |
| 152 proc `==`*(a, b: VkQueue): bool = uint(a) == uint(b) | |
| 153 proc `$`*(handle: VkCommandBuffer): string = "VkCommandBuffer(" & $(uint(handle)) & ")" | |
| 154 proc Valid*(handle: VkCommandBuffer): bool = uint(handle) != 0 | |
| 155 proc Reset*(handle: var VkCommandBuffer) = handle = VkCommandBuffer(0) | |
| 156 proc `==`*(a, b: VkCommandBuffer): bool = uint(a) == uint(b) | |
| 157 proc `$`*(handle: VkDeviceMemory): string = "VkDeviceMemory(" & $(uint(handle)) & ")" | |
| 158 proc Valid*(handle: VkDeviceMemory): bool = uint(handle) != 0 | |
| 159 proc Reset*(handle: var VkDeviceMemory) = handle = VkDeviceMemory(0) | |
| 160 proc `==`*(a, b: VkDeviceMemory): bool = uint(a) == uint(b) | |
| 161 proc `$`*(handle: VkCommandPool): string = "VkCommandPool(" & $(uint(handle)) & ")" | |
| 162 proc Valid*(handle: VkCommandPool): bool = uint(handle) != 0 | |
| 163 proc Reset*(handle: var VkCommandPool) = handle = VkCommandPool(0) | |
| 164 proc `==`*(a, b: VkCommandPool): bool = uint(a) == uint(b) | |
| 165 proc `$`*(handle: VkBuffer): string = "VkBuffer(" & $(uint(handle)) & ")" | |
| 166 proc Valid*(handle: VkBuffer): bool = uint(handle) != 0 | |
| 167 proc Reset*(handle: var VkBuffer) = handle = VkBuffer(0) | |
| 168 proc `==`*(a, b: VkBuffer): bool = uint(a) == uint(b) | |
| 169 proc `$`*(handle: VkBufferView): string = "VkBufferView(" & $(uint(handle)) & ")" | |
| 170 proc Valid*(handle: VkBufferView): bool = uint(handle) != 0 | |
| 171 proc Reset*(handle: var VkBufferView) = handle = VkBufferView(0) | |
| 172 proc `==`*(a, b: VkBufferView): bool = uint(a) == uint(b) | |
| 173 proc `$`*(handle: VkImage): string = "VkImage(" & $(uint(handle)) & ")" | |
| 174 proc Valid*(handle: VkImage): bool = uint(handle) != 0 | |
| 175 proc Reset*(handle: var VkImage) = handle = VkImage(0) | |
| 176 proc `==`*(a, b: VkImage): bool = uint(a) == uint(b) | |
| 177 proc `$`*(handle: VkImageView): string = "VkImageView(" & $(uint(handle)) & ")" | |
| 178 proc Valid*(handle: VkImageView): bool = uint(handle) != 0 | |
| 179 proc Reset*(handle: var VkImageView) = handle = VkImageView(0) | |
| 180 proc `==`*(a, b: VkImageView): bool = uint(a) == uint(b) | |
| 181 proc `$`*(handle: VkShaderModule): string = "VkShaderModule(" & $(uint(handle)) & ")" | |
| 182 proc Valid*(handle: VkShaderModule): bool = uint(handle) != 0 | |
| 183 proc Reset*(handle: var VkShaderModule) = handle = VkShaderModule(0) | |
| 184 proc `==`*(a, b: VkShaderModule): bool = uint(a) == uint(b) | |
| 185 proc `$`*(handle: VkPipeline): string = "VkPipeline(" & $(uint(handle)) & ")" | |
| 186 proc Valid*(handle: VkPipeline): bool = uint(handle) != 0 | |
| 187 proc Reset*(handle: var VkPipeline) = handle = VkPipeline(0) | |
| 188 proc `==`*(a, b: VkPipeline): bool = uint(a) == uint(b) | |
| 189 proc `$`*(handle: VkPipelineLayout): string = "VkPipelineLayout(" & $(uint(handle)) & ")" | |
| 190 proc Valid*(handle: VkPipelineLayout): bool = uint(handle) != 0 | |
| 191 proc Reset*(handle: var VkPipelineLayout) = handle = VkPipelineLayout(0) | |
| 192 proc `==`*(a, b: VkPipelineLayout): bool = uint(a) == uint(b) | |
| 193 proc `$`*(handle: VkSampler): string = "VkSampler(" & $(uint(handle)) & ")" | |
| 194 proc Valid*(handle: VkSampler): bool = uint(handle) != 0 | |
| 195 proc Reset*(handle: var VkSampler) = handle = VkSampler(0) | |
| 196 proc `==`*(a, b: VkSampler): bool = uint(a) == uint(b) | |
| 197 proc `$`*(handle: VkDescriptorSet): string = "VkDescriptorSet(" & $(uint(handle)) & ")" | |
| 198 proc Valid*(handle: VkDescriptorSet): bool = uint(handle) != 0 | |
| 199 proc Reset*(handle: var VkDescriptorSet) = handle = VkDescriptorSet(0) | |
| 200 proc `==`*(a, b: VkDescriptorSet): bool = uint(a) == uint(b) | |
| 201 proc `$`*(handle: VkDescriptorSetLayout): string = "VkDescriptorSetLayout(" & $(uint(handle)) & ")" | |
| 202 proc Valid*(handle: VkDescriptorSetLayout): bool = uint(handle) != 0 | |
| 203 proc Reset*(handle: var VkDescriptorSetLayout) = handle = VkDescriptorSetLayout(0) | |
| 204 proc `==`*(a, b: VkDescriptorSetLayout): bool = uint(a) == uint(b) | |
| 205 proc `$`*(handle: VkDescriptorPool): string = "VkDescriptorPool(" & $(uint(handle)) & ")" | |
| 206 proc Valid*(handle: VkDescriptorPool): bool = uint(handle) != 0 | |
| 207 proc Reset*(handle: var VkDescriptorPool) = handle = VkDescriptorPool(0) | |
| 208 proc `==`*(a, b: VkDescriptorPool): bool = uint(a) == uint(b) | |
| 209 proc `$`*(handle: VkFence): string = "VkFence(" & $(uint(handle)) & ")" | |
| 210 proc Valid*(handle: VkFence): bool = uint(handle) != 0 | |
| 211 proc Reset*(handle: var VkFence) = handle = VkFence(0) | |
| 212 proc `==`*(a, b: VkFence): bool = uint(a) == uint(b) | |
| 213 proc `$`*(handle: VkSemaphore): string = "VkSemaphore(" & $(uint(handle)) & ")" | |
| 214 proc Valid*(handle: VkSemaphore): bool = uint(handle) != 0 | |
| 215 proc Reset*(handle: var VkSemaphore) = handle = VkSemaphore(0) | |
| 216 proc `==`*(a, b: VkSemaphore): bool = uint(a) == uint(b) | |
| 217 proc `$`*(handle: VkEvent): string = "VkEvent(" & $(uint(handle)) & ")" | |
| 218 proc Valid*(handle: VkEvent): bool = uint(handle) != 0 | |
| 219 proc Reset*(handle: var VkEvent) = handle = VkEvent(0) | |
| 220 proc `==`*(a, b: VkEvent): bool = uint(a) == uint(b) | |
| 221 proc `$`*(handle: VkQueryPool): string = "VkQueryPool(" & $(uint(handle)) & ")" | |
| 222 proc Valid*(handle: VkQueryPool): bool = uint(handle) != 0 | |
| 223 proc Reset*(handle: var VkQueryPool) = handle = VkQueryPool(0) | |
| 224 proc `==`*(a, b: VkQueryPool): bool = uint(a) == uint(b) | |
| 225 proc `$`*(handle: VkFramebuffer): string = "VkFramebuffer(" & $(uint(handle)) & ")" | |
| 226 proc Valid*(handle: VkFramebuffer): bool = uint(handle) != 0 | |
| 227 proc Reset*(handle: var VkFramebuffer) = handle = VkFramebuffer(0) | |
| 228 proc `==`*(a, b: VkFramebuffer): bool = uint(a) == uint(b) | |
| 229 proc `$`*(handle: VkRenderPass): string = "VkRenderPass(" & $(uint(handle)) & ")" | |
| 230 proc Valid*(handle: VkRenderPass): bool = uint(handle) != 0 | |
| 231 proc Reset*(handle: var VkRenderPass) = handle = VkRenderPass(0) | |
| 232 proc `==`*(a, b: VkRenderPass): bool = uint(a) == uint(b) | |
| 233 proc `$`*(handle: VkPipelineCache): string = "VkPipelineCache(" & $(uint(handle)) & ")" | |
| 234 proc Valid*(handle: VkPipelineCache): bool = uint(handle) != 0 | |
| 235 proc Reset*(handle: var VkPipelineCache) = handle = VkPipelineCache(0) | |
| 236 proc `==`*(a, b: VkPipelineCache): bool = uint(a) == uint(b) | |
| 237 proc `$`*(handle: VkIndirectCommandsLayoutNV): string = "VkIndirectCommandsLayoutNV(" & $(uint(handle)) & ")" | |
| 238 proc Valid*(handle: VkIndirectCommandsLayoutNV): bool = uint(handle) != 0 | |
| 239 proc Reset*(handle: var VkIndirectCommandsLayoutNV) = handle = VkIndirectCommandsLayoutNV(0) | |
| 240 proc `==`*(a, b: VkIndirectCommandsLayoutNV): bool = uint(a) == uint(b) | |
| 241 proc `$`*(handle: VkDescriptorUpdateTemplate): string = "VkDescriptorUpdateTemplate(" & $(uint(handle)) & ")" | |
| 242 proc Valid*(handle: VkDescriptorUpdateTemplate): bool = uint(handle) != 0 | |
| 243 proc Reset*(handle: var VkDescriptorUpdateTemplate) = handle = VkDescriptorUpdateTemplate(0) | |
| 244 proc `==`*(a, b: VkDescriptorUpdateTemplate): bool = uint(a) == uint(b) | |
| 245 proc `$`*(handle: VkSamplerYcbcrConversion): string = "VkSamplerYcbcrConversion(" & $(uint(handle)) & ")" | |
| 246 proc Valid*(handle: VkSamplerYcbcrConversion): bool = uint(handle) != 0 | |
| 247 proc Reset*(handle: var VkSamplerYcbcrConversion) = handle = VkSamplerYcbcrConversion(0) | |
| 248 proc `==`*(a, b: VkSamplerYcbcrConversion): bool = uint(a) == uint(b) | |
| 249 proc `$`*(handle: VkValidationCacheEXT): string = "VkValidationCacheEXT(" & $(uint(handle)) & ")" | |
| 250 proc Valid*(handle: VkValidationCacheEXT): bool = uint(handle) != 0 | |
| 251 proc Reset*(handle: var VkValidationCacheEXT) = handle = VkValidationCacheEXT(0) | |
| 252 proc `==`*(a, b: VkValidationCacheEXT): bool = uint(a) == uint(b) | |
| 253 proc `$`*(handle: VkAccelerationStructureKHR): string = "VkAccelerationStructureKHR(" & $(uint(handle)) & ")" | |
| 254 proc Valid*(handle: VkAccelerationStructureKHR): bool = uint(handle) != 0 | |
| 255 proc Reset*(handle: var VkAccelerationStructureKHR) = handle = VkAccelerationStructureKHR(0) | |
| 256 proc `==`*(a, b: VkAccelerationStructureKHR): bool = uint(a) == uint(b) | |
| 257 proc `$`*(handle: VkAccelerationStructureNV): string = "VkAccelerationStructureNV(" & $(uint(handle)) & ")" | |
| 258 proc Valid*(handle: VkAccelerationStructureNV): bool = uint(handle) != 0 | |
| 259 proc Reset*(handle: var VkAccelerationStructureNV) = handle = VkAccelerationStructureNV(0) | |
| 260 proc `==`*(a, b: VkAccelerationStructureNV): bool = uint(a) == uint(b) | |
| 261 proc `$`*(handle: VkPerformanceConfigurationINTEL): string = "VkPerformanceConfigurationINTEL(" & $(uint(handle)) & ")" | |
| 262 proc Valid*(handle: VkPerformanceConfigurationINTEL): bool = uint(handle) != 0 | |
| 263 proc Reset*(handle: var VkPerformanceConfigurationINTEL) = handle = VkPerformanceConfigurationINTEL(0) | |
| 264 proc `==`*(a, b: VkPerformanceConfigurationINTEL): bool = uint(a) == uint(b) | |
| 265 proc `$`*(handle: VkBufferCollectionFUCHSIA): string = "VkBufferCollectionFUCHSIA(" & $(uint(handle)) & ")" | |
| 266 proc Valid*(handle: VkBufferCollectionFUCHSIA): bool = uint(handle) != 0 | |
| 267 proc Reset*(handle: var VkBufferCollectionFUCHSIA) = handle = VkBufferCollectionFUCHSIA(0) | |
| 268 proc `==`*(a, b: VkBufferCollectionFUCHSIA): bool = uint(a) == uint(b) | |
| 269 proc `$`*(handle: VkDeferredOperationKHR): string = "VkDeferredOperationKHR(" & $(uint(handle)) & ")" | |
| 270 proc Valid*(handle: VkDeferredOperationKHR): bool = uint(handle) != 0 | |
| 271 proc Reset*(handle: var VkDeferredOperationKHR) = handle = VkDeferredOperationKHR(0) | |
| 272 proc `==`*(a, b: VkDeferredOperationKHR): bool = uint(a) == uint(b) | |
| 273 proc `$`*(handle: VkPrivateDataSlot): string = "VkPrivateDataSlot(" & $(uint(handle)) & ")" | |
| 274 proc Valid*(handle: VkPrivateDataSlot): bool = uint(handle) != 0 | |
| 275 proc Reset*(handle: var VkPrivateDataSlot) = handle = VkPrivateDataSlot(0) | |
| 276 proc `==`*(a, b: VkPrivateDataSlot): bool = uint(a) == uint(b) | |
| 277 proc `$`*(handle: VkCuModuleNVX): string = "VkCuModuleNVX(" & $(uint(handle)) & ")" | |
| 278 proc Valid*(handle: VkCuModuleNVX): bool = uint(handle) != 0 | |
| 279 proc Reset*(handle: var VkCuModuleNVX) = handle = VkCuModuleNVX(0) | |
| 280 proc `==`*(a, b: VkCuModuleNVX): bool = uint(a) == uint(b) | |
| 281 proc `$`*(handle: VkCuFunctionNVX): string = "VkCuFunctionNVX(" & $(uint(handle)) & ")" | |
| 282 proc Valid*(handle: VkCuFunctionNVX): bool = uint(handle) != 0 | |
| 283 proc Reset*(handle: var VkCuFunctionNVX) = handle = VkCuFunctionNVX(0) | |
| 284 proc `==`*(a, b: VkCuFunctionNVX): bool = uint(a) == uint(b) | |
| 285 proc `$`*(handle: VkOpticalFlowSessionNV): string = "VkOpticalFlowSessionNV(" & $(uint(handle)) & ")" | |
| 286 proc Valid*(handle: VkOpticalFlowSessionNV): bool = uint(handle) != 0 | |
| 287 proc Reset*(handle: var VkOpticalFlowSessionNV) = handle = VkOpticalFlowSessionNV(0) | |
| 288 proc `==`*(a, b: VkOpticalFlowSessionNV): bool = uint(a) == uint(b) | |
| 289 proc `$`*(handle: VkMicromapEXT): string = "VkMicromapEXT(" & $(uint(handle)) & ")" | |
| 290 proc Valid*(handle: VkMicromapEXT): bool = uint(handle) != 0 | |
| 291 proc Reset*(handle: var VkMicromapEXT) = handle = VkMicromapEXT(0) | |
| 292 proc `==`*(a, b: VkMicromapEXT): bool = uint(a) == uint(b) | |
| 293 proc `$`*(handle: VkDisplayKHR): string = "VkDisplayKHR(" & $(uint(handle)) & ")" | |
| 294 proc Valid*(handle: VkDisplayKHR): bool = uint(handle) != 0 | |
| 295 proc Reset*(handle: var VkDisplayKHR) = handle = VkDisplayKHR(0) | |
| 296 proc `==`*(a, b: VkDisplayKHR): bool = uint(a) == uint(b) | |
| 297 proc `$`*(handle: VkDisplayModeKHR): string = "VkDisplayModeKHR(" & $(uint(handle)) & ")" | |
| 298 proc Valid*(handle: VkDisplayModeKHR): bool = uint(handle) != 0 | |
| 299 proc Reset*(handle: var VkDisplayModeKHR) = handle = VkDisplayModeKHR(0) | |
| 300 proc `==`*(a, b: VkDisplayModeKHR): bool = uint(a) == uint(b) | |
| 301 proc `$`*(handle: VkSurfaceKHR): string = "VkSurfaceKHR(" & $(uint(handle)) & ")" | |
| 302 proc Valid*(handle: VkSurfaceKHR): bool = uint(handle) != 0 | |
| 303 proc Reset*(handle: var VkSurfaceKHR) = handle = VkSurfaceKHR(0) | |
| 304 proc `==`*(a, b: VkSurfaceKHR): bool = uint(a) == uint(b) | |
| 305 proc `$`*(handle: VkSwapchainKHR): string = "VkSwapchainKHR(" & $(uint(handle)) & ")" | |
| 306 proc Valid*(handle: VkSwapchainKHR): bool = uint(handle) != 0 | |
| 307 proc Reset*(handle: var VkSwapchainKHR) = handle = VkSwapchainKHR(0) | |
| 308 proc `==`*(a, b: VkSwapchainKHR): bool = uint(a) == uint(b) | |
| 309 proc `$`*(handle: VkDebugReportCallbackEXT): string = "VkDebugReportCallbackEXT(" & $(uint(handle)) & ")" | |
| 310 proc Valid*(handle: VkDebugReportCallbackEXT): bool = uint(handle) != 0 | |
| 311 proc Reset*(handle: var VkDebugReportCallbackEXT) = handle = VkDebugReportCallbackEXT(0) | |
| 312 proc `==`*(a, b: VkDebugReportCallbackEXT): bool = uint(a) == uint(b) | |
| 313 proc `$`*(handle: VkDebugUtilsMessengerEXT): string = "VkDebugUtilsMessengerEXT(" & $(uint(handle)) & ")" | |
| 314 proc Valid*(handle: VkDebugUtilsMessengerEXT): bool = uint(handle) != 0 | |
| 315 proc Reset*(handle: var VkDebugUtilsMessengerEXT) = handle = VkDebugUtilsMessengerEXT(0) | |
| 316 proc `==`*(a, b: VkDebugUtilsMessengerEXT): bool = uint(a) == uint(b) | |
| 317 proc `$`*(handle: VkVideoSessionKHR): string = "VkVideoSessionKHR(" & $(uint(handle)) & ")" | |
| 318 proc Valid*(handle: VkVideoSessionKHR): bool = uint(handle) != 0 | |
| 319 proc Reset*(handle: var VkVideoSessionKHR) = handle = VkVideoSessionKHR(0) | |
| 320 proc `==`*(a, b: VkVideoSessionKHR): bool = uint(a) == uint(b) | |
| 321 proc `$`*(handle: VkVideoSessionParametersKHR): string = "VkVideoSessionParametersKHR(" & $(uint(handle)) & ")" | |
| 322 proc Valid*(handle: VkVideoSessionParametersKHR): bool = uint(handle) != 0 | |
| 323 proc Reset*(handle: var VkVideoSessionParametersKHR) = handle = VkVideoSessionParametersKHR(0) | |
| 324 proc `==`*(a, b: VkVideoSessionParametersKHR): bool = uint(a) == uint(b) | |
| 325 proc `$`*(handle: VkSemaphoreSciSyncPoolNV): string = "VkSemaphoreSciSyncPoolNV(" & $(uint(handle)) & ")" | |
| 326 proc Valid*(handle: VkSemaphoreSciSyncPoolNV): bool = uint(handle) != 0 | |
| 327 proc Reset*(handle: var VkSemaphoreSciSyncPoolNV) = handle = VkSemaphoreSciSyncPoolNV(0) | |
| 328 proc `==`*(a, b: VkSemaphoreSciSyncPoolNV): bool = uint(a) == uint(b) | |
| 329 type | |
| 330 VkFramebufferCreateFlags* = distinct VkFlags | |
| 331 VkQueryPoolCreateFlags* = distinct VkFlags | |
| 332 VkRenderPassCreateFlags* = distinct VkFlags | |
| 333 VkSamplerCreateFlags* = distinct VkFlags | |
| 334 VkPipelineLayoutCreateFlags* = distinct VkFlags | |
| 335 VkPipelineCacheCreateFlags* = distinct VkFlags | |
| 336 VkPipelineDepthStencilStateCreateFlags* = distinct VkFlags | |
| 337 VkPipelineDynamicStateCreateFlags* = distinct VkFlags | |
| 338 VkPipelineColorBlendStateCreateFlags* = distinct VkFlags | |
| 339 VkPipelineMultisampleStateCreateFlags* = distinct VkFlags | |
| 340 VkPipelineRasterizationStateCreateFlags* = distinct VkFlags | |
| 341 VkPipelineViewportStateCreateFlags* = distinct VkFlags | |
| 342 VkPipelineTessellationStateCreateFlags* = distinct VkFlags | |
| 343 VkPipelineInputAssemblyStateCreateFlags* = distinct VkFlags | |
| 344 VkPipelineVertexInputStateCreateFlags* = distinct VkFlags | |
| 345 VkPipelineShaderStageCreateFlags* = distinct VkFlags | |
| 346 VkDescriptorSetLayoutCreateFlags* = distinct VkFlags | |
| 347 VkBufferViewCreateFlags* = distinct VkFlags | |
| 348 VkInstanceCreateFlags* = distinct VkFlags | |
| 349 VkDeviceCreateFlags* = distinct VkFlags | |
| 350 VkDeviceQueueCreateFlags* = distinct VkFlags | |
| 351 VkQueueFlags* = distinct VkFlags | |
| 352 VkMemoryPropertyFlags* = distinct VkFlags | |
| 353 VkMemoryHeapFlags* = distinct VkFlags | |
| 354 VkAccessFlags* = distinct VkFlags | |
| 355 VkBufferUsageFlags* = distinct VkFlags | |
| 356 VkBufferCreateFlags* = distinct VkFlags | |
| 357 VkShaderStageFlags* = distinct VkFlags | |
| 358 VkImageUsageFlags* = distinct VkFlags | |
| 359 VkImageCreateFlags* = distinct VkFlags | |
| 360 VkImageViewCreateFlags* = distinct VkFlags | |
| 361 VkPipelineCreateFlags* = distinct VkFlags | |
| 362 VkColorComponentFlags* = distinct VkFlags | |
| 363 VkFenceCreateFlags* = distinct VkFlags | |
| 364 VkSemaphoreCreateFlags* = distinct VkFlags | |
| 365 VkFormatFeatureFlags* = distinct VkFlags | |
| 366 VkQueryControlFlags* = distinct VkFlags | |
| 367 VkQueryResultFlags* = distinct VkFlags | |
| 368 VkShaderModuleCreateFlags* = distinct VkFlags | |
| 369 VkEventCreateFlags* = distinct VkFlags | |
| 370 VkCommandPoolCreateFlags* = distinct VkFlags | |
| 371 VkCommandPoolResetFlags* = distinct VkFlags | |
| 372 VkCommandBufferResetFlags* = distinct VkFlags | |
| 373 VkCommandBufferUsageFlags* = distinct VkFlags | |
| 374 VkQueryPipelineStatisticFlags* = distinct VkFlags | |
| 375 VkMemoryMapFlags* = distinct VkFlags | |
| 376 VkImageAspectFlags* = distinct VkFlags | |
| 377 VkSparseMemoryBindFlags* = distinct VkFlags | |
| 378 VkSparseImageFormatFlags* = distinct VkFlags | |
| 379 VkSubpassDescriptionFlags* = distinct VkFlags | |
| 380 VkPipelineStageFlags* = distinct VkFlags | |
| 381 VkSampleCountFlags* = distinct VkFlags | |
| 382 VkAttachmentDescriptionFlags* = distinct VkFlags | |
| 383 VkStencilFaceFlags* = distinct VkFlags | |
| 384 VkCullModeFlags* = distinct VkFlags | |
| 385 VkDescriptorPoolCreateFlags* = distinct VkFlags | |
| 386 VkDescriptorPoolResetFlags* = distinct VkFlags | |
| 387 VkDependencyFlags* = distinct VkFlags | |
| 388 VkSubgroupFeatureFlags* = distinct VkFlags | |
| 389 VkIndirectCommandsLayoutUsageFlagsNV* = distinct VkFlags | |
| 390 VkIndirectStateFlagsNV* = distinct VkFlags | |
| 391 VkGeometryFlagsKHR* = distinct VkFlags | |
| 392 VkGeometryInstanceFlagsKHR* = distinct VkFlags | |
| 393 VkBuildAccelerationStructureFlagsKHR* = distinct VkFlags | |
| 394 VkPrivateDataSlotCreateFlags* = distinct VkFlags | |
| 395 VkAccelerationStructureCreateFlagsKHR* = distinct VkFlags | |
| 396 VkDescriptorUpdateTemplateCreateFlags* = distinct VkFlags | |
| 397 VkPipelineCreationFeedbackFlags* = distinct VkFlags | |
| 398 VkPerformanceCounterDescriptionFlagsKHR* = distinct VkFlags | |
| 399 VkAcquireProfilingLockFlagsKHR* = distinct VkFlags | |
| 400 VkSemaphoreWaitFlags* = distinct VkFlags | |
| 401 VkPipelineCompilerControlFlagsAMD* = distinct VkFlags | |
| 402 VkShaderCorePropertiesFlagsAMD* = distinct VkFlags | |
| 403 VkDeviceDiagnosticsConfigFlagsNV* = distinct VkFlags | |
| 404 VkRefreshObjectFlagsKHR* = distinct VkFlags | |
| 405 VkAccessFlags2* = distinct VkFlags64 | |
| 406 VkPipelineStageFlags2* = distinct VkFlags64 | |
| 407 VkAccelerationStructureMotionInfoFlagsNV* = distinct VkFlags | |
| 408 VkAccelerationStructureMotionInstanceFlagsNV* = distinct VkFlags | |
| 409 VkFormatFeatureFlags2* = distinct VkFlags64 | |
| 410 VkRenderingFlags* = distinct VkFlags | |
| 411 VkMemoryDecompressionMethodFlagsNV* = distinct VkFlags64 | |
| 412 VkBuildMicromapFlagsEXT* = distinct VkFlags | |
| 413 VkMicromapCreateFlagsEXT* = distinct VkFlags | |
| 414 VkDirectDriverLoadingFlagsLUNARG* = distinct VkFlags | |
| 415 VkCompositeAlphaFlagsKHR* = distinct VkFlags | |
| 416 VkDisplayPlaneAlphaFlagsKHR* = distinct VkFlags | |
| 417 VkSurfaceTransformFlagsKHR* = distinct VkFlags | |
| 418 VkSwapchainCreateFlagsKHR* = distinct VkFlags | |
| 419 VkDisplayModeCreateFlagsKHR* = distinct VkFlags | |
| 420 VkDisplaySurfaceCreateFlagsKHR* = distinct VkFlags | |
| 421 VkAndroidSurfaceCreateFlagsKHR* = distinct VkFlags | |
| 422 VkViSurfaceCreateFlagsNN* = distinct VkFlags | |
| 423 VkWaylandSurfaceCreateFlagsKHR* = distinct VkFlags | |
| 424 VkWin32SurfaceCreateFlagsKHR* = distinct VkFlags | |
| 425 VkXlibSurfaceCreateFlagsKHR* = distinct VkFlags | |
| 426 VkXcbSurfaceCreateFlagsKHR* = distinct VkFlags | |
| 427 VkDirectFBSurfaceCreateFlagsEXT* = distinct VkFlags | |
| 428 VkIOSSurfaceCreateFlagsMVK* = distinct VkFlags | |
| 429 VkMacOSSurfaceCreateFlagsMVK* = distinct VkFlags | |
| 430 VkMetalSurfaceCreateFlagsEXT* = distinct VkFlags | |
| 431 VkImagePipeSurfaceCreateFlagsFUCHSIA* = distinct VkFlags | |
| 432 VkStreamDescriptorSurfaceCreateFlagsGGP* = distinct VkFlags | |
| 433 VkHeadlessSurfaceCreateFlagsEXT* = distinct VkFlags | |
| 434 VkScreenSurfaceCreateFlagsQNX* = distinct VkFlags | |
| 435 VkPeerMemoryFeatureFlags* = distinct VkFlags | |
| 436 VkMemoryAllocateFlags* = distinct VkFlags | |
| 437 VkDeviceGroupPresentModeFlagsKHR* = distinct VkFlags | |
| 438 VkDebugReportFlagsEXT* = distinct VkFlags | |
| 439 VkCommandPoolTrimFlags* = distinct VkFlags | |
| 440 VkExternalMemoryHandleTypeFlagsNV* = distinct VkFlags | |
| 441 VkExternalMemoryFeatureFlagsNV* = distinct VkFlags | |
| 442 VkExternalMemoryHandleTypeFlags* = distinct VkFlags | |
| 443 VkExternalMemoryFeatureFlags* = distinct VkFlags | |
| 444 VkExternalSemaphoreHandleTypeFlags* = distinct VkFlags | |
| 445 VkExternalSemaphoreFeatureFlags* = distinct VkFlags | |
| 446 VkSemaphoreImportFlags* = distinct VkFlags | |
| 447 VkExternalFenceHandleTypeFlags* = distinct VkFlags | |
| 448 VkExternalFenceFeatureFlags* = distinct VkFlags | |
| 449 VkFenceImportFlags* = distinct VkFlags | |
| 450 VkSurfaceCounterFlagsEXT* = distinct VkFlags | |
| 451 VkPipelineViewportSwizzleStateCreateFlagsNV* = distinct VkFlags | |
| 452 VkPipelineDiscardRectangleStateCreateFlagsEXT* = distinct VkFlags | |
| 453 VkPipelineCoverageToColorStateCreateFlagsNV* = distinct VkFlags | |
| 454 VkPipelineCoverageModulationStateCreateFlagsNV* = distinct VkFlags | |
| 455 VkPipelineCoverageReductionStateCreateFlagsNV* = distinct VkFlags | |
| 456 VkValidationCacheCreateFlagsEXT* = distinct VkFlags | |
| 457 VkDebugUtilsMessageSeverityFlagsEXT* = distinct VkFlags | |
| 458 VkDebugUtilsMessageTypeFlagsEXT* = distinct VkFlags | |
| 459 VkDebugUtilsMessengerCreateFlagsEXT* = distinct VkFlags | |
| 460 VkDebugUtilsMessengerCallbackDataFlagsEXT* = distinct VkFlags | |
| 461 VkDeviceMemoryReportFlagsEXT* = distinct VkFlags | |
| 462 VkPipelineRasterizationConservativeStateCreateFlagsEXT* = distinct VkFlags | |
| 463 VkDescriptorBindingFlags* = distinct VkFlags | |
| 464 VkConditionalRenderingFlagsEXT* = distinct VkFlags | |
| 465 VkResolveModeFlags* = distinct VkFlags | |
| 466 VkPipelineRasterizationStateStreamCreateFlagsEXT* = distinct VkFlags | |
| 467 VkPipelineRasterizationDepthClipStateCreateFlagsEXT* = distinct VkFlags | |
| 468 VkSwapchainImageUsageFlagsANDROID* = distinct VkFlags | |
| 469 VkToolPurposeFlags* = distinct VkFlags | |
| 470 VkSubmitFlags* = distinct VkFlags | |
| 471 VkImageFormatConstraintsFlagsFUCHSIA* = distinct VkFlags | |
| 472 VkImageConstraintsInfoFlagsFUCHSIA* = distinct VkFlags | |
| 473 VkGraphicsPipelineLibraryFlagsEXT* = distinct VkFlags | |
| 474 VkImageCompressionFlagsEXT* = distinct VkFlags | |
| 475 VkImageCompressionFixedRateFlagsEXT* = distinct VkFlags | |
| 476 VkExportMetalObjectTypeFlagsEXT* = distinct VkFlags | |
| 477 VkDeviceAddressBindingFlagsEXT* = distinct VkFlags | |
| 478 VkOpticalFlowGridSizeFlagsNV* = distinct VkFlags | |
| 479 VkOpticalFlowUsageFlagsNV* = distinct VkFlags | |
| 480 VkOpticalFlowSessionCreateFlagsNV* = distinct VkFlags | |
| 481 VkOpticalFlowExecuteFlagsNV* = distinct VkFlags | |
| 482 VkPresentScalingFlagsEXT* = distinct VkFlags | |
| 483 VkPresentGravityFlagsEXT* = distinct VkFlags | |
| 484 VkVideoCodecOperationFlagsKHR* = distinct VkFlags | |
| 485 VkVideoCapabilityFlagsKHR* = distinct VkFlags | |
| 486 VkVideoSessionCreateFlagsKHR* = distinct VkFlags | |
| 487 VkVideoSessionParametersCreateFlagsKHR* = distinct VkFlags | |
| 488 VkVideoBeginCodingFlagsKHR* = distinct VkFlags | |
| 489 VkVideoEndCodingFlagsKHR* = distinct VkFlags | |
| 490 VkVideoCodingControlFlagsKHR* = distinct VkFlags | |
| 491 VkVideoDecodeUsageFlagsKHR* = distinct VkFlags | |
| 492 VkVideoDecodeCapabilityFlagsKHR* = distinct VkFlags | |
| 493 VkVideoDecodeFlagsKHR* = distinct VkFlags | |
| 494 VkVideoDecodeH264PictureLayoutFlagsKHR* = distinct VkFlags | |
| 495 VkVideoEncodeFlagsKHR* = distinct VkFlags | |
| 496 VkVideoEncodeUsageFlagsKHR* = distinct VkFlags | |
| 497 VkVideoEncodeContentFlagsKHR* = distinct VkFlags | |
| 498 VkVideoEncodeCapabilityFlagsKHR* = distinct VkFlags | |
| 499 VkVideoEncodeRateControlFlagsKHR* = distinct VkFlags | |
| 500 VkVideoEncodeRateControlModeFlagsKHR* = distinct VkFlags | |
| 501 VkVideoChromaSubsamplingFlagsKHR* = distinct VkFlags | |
| 502 VkVideoComponentBitDepthFlagsKHR* = distinct VkFlags | |
| 503 VkVideoEncodeH264CapabilityFlagsEXT* = distinct VkFlags | |
| 504 VkVideoEncodeH264InputModeFlagsEXT* = distinct VkFlags | |
| 505 VkVideoEncodeH264OutputModeFlagsEXT* = distinct VkFlags | |
| 506 VkVideoEncodeH265CapabilityFlagsEXT* = distinct VkFlags | |
| 507 VkVideoEncodeH265InputModeFlagsEXT* = distinct VkFlags | |
| 508 VkVideoEncodeH265OutputModeFlagsEXT* = distinct VkFlags | |
| 509 VkVideoEncodeH265CtbSizeFlagsEXT* = distinct VkFlags | |
| 510 VkVideoEncodeH265TransformBlockSizeFlagsEXT* = distinct VkFlags | |
| 511 let vkGetInstanceProcAddr = cast[proc(instance: VkInstance, name: cstring): pointer {.stdcall.}](checkedSymAddr(vulkanLib, "vkGetInstanceProcAddr")) | |
| 512 type | |
| 513 VkImageLayout* {.size: sizeof(cint).} = enum | |
| 514 VK_IMAGE_LAYOUT_UNDEFINED = 0 | |
| 515 VK_IMAGE_LAYOUT_GENERAL = 1 | |
| 516 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2 | |
| 517 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3 | |
| 518 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4 | |
| 519 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5 | |
| 520 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6 | |
| 521 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7 | |
| 522 VK_IMAGE_LAYOUT_PREINITIALIZED = 8 | |
| 523 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002 | |
| 524 VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000 | |
| 525 VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001 | |
| 526 VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002 | |
| 527 VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000 | |
| 528 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000 | |
| 529 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001 | |
| 530 VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003 | |
| 531 VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000 | |
| 532 VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000 | |
| 533 VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001 | |
| 534 VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002 | |
| 535 VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003 | |
| 536 VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000 | |
| 537 VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001 | |
| 538 VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002 | |
| 539 VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000 | |
| 540 VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001 | |
| 541 VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000 | |
| 542 VkAttachmentLoadOp* {.size: sizeof(cint).} = enum | |
| 543 VK_ATTACHMENT_LOAD_OP_LOAD = 0 | |
| 544 VK_ATTACHMENT_LOAD_OP_CLEAR = 1 | |
| 545 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2 | |
| 546 VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000 | |
| 547 VkAttachmentStoreOp* {.size: sizeof(cint).} = enum | |
| 548 VK_ATTACHMENT_STORE_OP_STORE = 0 | |
| 549 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1 | |
| 550 VK_ATTACHMENT_STORE_OP_NONE = 1000301000 | |
| 551 VkImageType* {.size: sizeof(cint).} = enum | |
| 552 VK_IMAGE_TYPE_1D = 0 | |
| 553 VK_IMAGE_TYPE_2D = 1 | |
| 554 VK_IMAGE_TYPE_3D = 2 | |
| 555 VkImageTiling* {.size: sizeof(cint).} = enum | |
| 556 VK_IMAGE_TILING_OPTIMAL = 0 | |
| 557 VK_IMAGE_TILING_LINEAR = 1 | |
| 558 VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000 | |
| 559 VkImageViewType* {.size: sizeof(cint).} = enum | |
| 560 VK_IMAGE_VIEW_TYPE_1D = 0 | |
| 561 VK_IMAGE_VIEW_TYPE_2D = 1 | |
| 562 VK_IMAGE_VIEW_TYPE_3D = 2 | |
| 563 VK_IMAGE_VIEW_TYPE_CUBE = 3 | |
| 564 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4 | |
| 565 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5 | |
| 566 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6 | |
| 567 VkCommandBufferLevel* {.size: sizeof(cint).} = enum | |
| 568 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0 | |
| 569 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1 | |
| 570 VkComponentSwizzle* {.size: sizeof(cint).} = enum | |
| 571 VK_COMPONENT_SWIZZLE_IDENTITY = 0 | |
| 572 VK_COMPONENT_SWIZZLE_ZERO = 1 | |
| 573 VK_COMPONENT_SWIZZLE_ONE = 2 | |
| 574 VK_COMPONENT_SWIZZLE_R = 3 | |
| 575 VK_COMPONENT_SWIZZLE_G = 4 | |
| 576 VK_COMPONENT_SWIZZLE_B = 5 | |
| 577 VK_COMPONENT_SWIZZLE_A = 6 | |
| 578 VkDescriptorType* {.size: sizeof(cint).} = enum | |
| 579 VK_DESCRIPTOR_TYPE_SAMPLER = 0 | |
| 580 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1 | |
| 581 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2 | |
| 582 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3 | |
| 583 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4 | |
| 584 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5 | |
| 585 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6 | |
| 586 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7 | |
| 587 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8 | |
| 588 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9 | |
| 589 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10 | |
| 590 VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000 | |
| 591 VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000 | |
| 592 VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000 | |
| 593 VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000 | |
| 594 VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000 | |
| 595 VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001 | |
| 596 VkQueryType* {.size: sizeof(cint).} = enum | |
| 597 VK_QUERY_TYPE_OCCLUSION = 0 | |
| 598 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1 | |
| 599 VK_QUERY_TYPE_TIMESTAMP = 2 | |
| 600 VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000 | |
| 601 VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004 | |
| 602 VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000 | |
| 603 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000 | |
| 604 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001 | |
| 605 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000 | |
| 606 VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000 | |
| 607 VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000 | |
| 608 VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000 | |
| 609 VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000 | |
| 610 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000 | |
| 611 VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001 | |
| 612 VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000 | |
| 613 VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001 | |
| 614 VkBorderColor* {.size: sizeof(cint).} = enum | |
| 615 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0 | |
| 616 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1 | |
| 617 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2 | |
| 618 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3 | |
| 619 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4 | |
| 620 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5 | |
| 621 VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003 | |
| 622 VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004 | |
| 623 VkPipelineBindPoint* {.size: sizeof(cint).} = enum | |
| 624 VK_PIPELINE_BIND_POINT_GRAPHICS = 0 | |
| 625 VK_PIPELINE_BIND_POINT_COMPUTE = 1 | |
| 626 VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000 | |
| 627 VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003 | |
| 628 VkPipelineCacheHeaderVersion* {.size: sizeof(cint).} = enum | |
| 629 VK_PIPELINE_CACHE_HEADER_VERSION_ONE_ENUM = 1 | |
| 630 VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE_ENUM = 1000298001 | |
| 631 VkPipelineCacheCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 632 VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0b00000000000000000000000000000001 | |
| 633 VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT = 0b00000000000000000000000000000010 | |
| 634 VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT = 0b00000000000000000000000000000100 | |
| 635 func toBits*(flags: openArray[VkPipelineCacheCreateFlagBits]): VkPipelineCacheCreateFlags = | |
| 636 for flag in flags: | |
| 637 result = VkPipelineCacheCreateFlags(uint(result) or uint(flag)) | |
| 638 func toEnums*(number: VkPipelineCacheCreateFlags): seq[VkPipelineCacheCreateFlagBits] = | |
| 639 for value in VkPipelineCacheCreateFlagBits.items: | |
| 640 if (value.ord and cint(number)) > 0: | |
| 641 result.add value | |
| 642 proc `==`*(a, b: VkPipelineCacheCreateFlags): bool = cint(a) == cint(b) | |
| 643 type | |
| 644 VkPrimitiveTopology* {.size: sizeof(cint).} = enum | |
| 645 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0 | |
| 646 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1 | |
| 647 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2 | |
| 648 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3 | |
| 649 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4 | |
| 650 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5 | |
| 651 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6 | |
| 652 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7 | |
| 653 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8 | |
| 654 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9 | |
| 655 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10 | |
| 656 VkSharingMode* {.size: sizeof(cint).} = enum | |
| 657 VK_SHARING_MODE_EXCLUSIVE = 0 | |
| 658 VK_SHARING_MODE_CONCURRENT = 1 | |
| 659 VkIndexType* {.size: sizeof(cint).} = enum | |
| 660 VK_INDEX_TYPE_UINT16 = 0 | |
| 661 VK_INDEX_TYPE_UINT32 = 1 | |
| 662 VK_INDEX_TYPE_NONE_KHR = 1000165000 | |
| 663 VK_INDEX_TYPE_UINT8_EXT = 1000265000 | |
| 664 VkFilter* {.size: sizeof(cint).} = enum | |
| 665 VK_FILTER_NEAREST = 0 | |
| 666 VK_FILTER_LINEAR = 1 | |
| 667 VK_FILTER_CUBIC_EXT = 1000015000 | |
| 668 VkSamplerMipmapMode* {.size: sizeof(cint).} = enum | |
| 669 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0 | |
| 670 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1 | |
| 671 VkSamplerAddressMode* {.size: sizeof(cint).} = enum | |
| 672 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0 | |
| 673 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1 | |
| 674 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2 | |
| 675 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3 | |
| 676 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4 | |
| 677 VkCompareOp* {.size: sizeof(cint).} = enum | |
| 678 VK_COMPARE_OP_NEVER = 0 | |
| 679 VK_COMPARE_OP_LESS = 1 | |
| 680 VK_COMPARE_OP_EQUAL = 2 | |
| 681 VK_COMPARE_OP_LESS_OR_EQUAL = 3 | |
| 682 VK_COMPARE_OP_GREATER = 4 | |
| 683 VK_COMPARE_OP_NOT_EQUAL = 5 | |
| 684 VK_COMPARE_OP_GREATER_OR_EQUAL = 6 | |
| 685 VK_COMPARE_OP_ALWAYS = 7 | |
| 686 VkPolygonMode* {.size: sizeof(cint).} = enum | |
| 687 VK_POLYGON_MODE_FILL = 0 | |
| 688 VK_POLYGON_MODE_LINE = 1 | |
| 689 VK_POLYGON_MODE_POINT = 2 | |
| 690 VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000 | |
| 691 VkFrontFace* {.size: sizeof(cint).} = enum | |
| 692 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0 | |
| 693 VK_FRONT_FACE_CLOCKWISE = 1 | |
| 694 VkBlendFactor* {.size: sizeof(cint).} = enum | |
| 695 VK_BLEND_FACTOR_ZERO = 0 | |
| 696 VK_BLEND_FACTOR_ONE = 1 | |
| 697 VK_BLEND_FACTOR_SRC_COLOR = 2 | |
| 698 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3 | |
| 699 VK_BLEND_FACTOR_DST_COLOR = 4 | |
| 700 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5 | |
| 701 VK_BLEND_FACTOR_SRC_ALPHA = 6 | |
| 702 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7 | |
| 703 VK_BLEND_FACTOR_DST_ALPHA = 8 | |
| 704 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9 | |
| 705 VK_BLEND_FACTOR_CONSTANT_COLOR = 10 | |
| 706 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11 | |
| 707 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12 | |
| 708 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13 | |
| 709 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14 | |
| 710 VK_BLEND_FACTOR_SRC1_COLOR = 15 | |
| 711 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16 | |
| 712 VK_BLEND_FACTOR_SRC1_ALPHA = 17 | |
| 713 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18 | |
| 714 VkBlendOp* {.size: sizeof(cint).} = enum | |
| 715 VK_BLEND_OP_ADD = 0 | |
| 716 VK_BLEND_OP_SUBTRACT = 1 | |
| 717 VK_BLEND_OP_REVERSE_SUBTRACT = 2 | |
| 718 VK_BLEND_OP_MIN = 3 | |
| 719 VK_BLEND_OP_MAX = 4 | |
| 720 VK_BLEND_OP_ZERO_EXT = 1000148000 | |
| 721 VK_BLEND_OP_SRC_EXT = 1000148001 | |
| 722 VK_BLEND_OP_DST_EXT = 1000148002 | |
| 723 VK_BLEND_OP_SRC_OVER_EXT = 1000148003 | |
| 724 VK_BLEND_OP_DST_OVER_EXT = 1000148004 | |
| 725 VK_BLEND_OP_SRC_IN_EXT = 1000148005 | |
| 726 VK_BLEND_OP_DST_IN_EXT = 1000148006 | |
| 727 VK_BLEND_OP_SRC_OUT_EXT = 1000148007 | |
| 728 VK_BLEND_OP_DST_OUT_EXT = 1000148008 | |
| 729 VK_BLEND_OP_SRC_ATOP_EXT = 1000148009 | |
| 730 VK_BLEND_OP_DST_ATOP_EXT = 1000148010 | |
| 731 VK_BLEND_OP_XOR_EXT = 1000148011 | |
| 732 VK_BLEND_OP_MULTIPLY_EXT = 1000148012 | |
| 733 VK_BLEND_OP_SCREEN_EXT = 1000148013 | |
| 734 VK_BLEND_OP_OVERLAY_EXT = 1000148014 | |
| 735 VK_BLEND_OP_DARKEN_EXT = 1000148015 | |
| 736 VK_BLEND_OP_LIGHTEN_EXT = 1000148016 | |
| 737 VK_BLEND_OP_COLORDODGE_EXT = 1000148017 | |
| 738 VK_BLEND_OP_COLORBURN_EXT = 1000148018 | |
| 739 VK_BLEND_OP_HARDLIGHT_EXT = 1000148019 | |
| 740 VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020 | |
| 741 VK_BLEND_OP_DIFFERENCE_EXT = 1000148021 | |
| 742 VK_BLEND_OP_EXCLUSION_EXT = 1000148022 | |
| 743 VK_BLEND_OP_INVERT_EXT = 1000148023 | |
| 744 VK_BLEND_OP_INVERT_RGB_EXT = 1000148024 | |
| 745 VK_BLEND_OP_LINEARDODGE_EXT = 1000148025 | |
| 746 VK_BLEND_OP_LINEARBURN_EXT = 1000148026 | |
| 747 VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027 | |
| 748 VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028 | |
| 749 VK_BLEND_OP_PINLIGHT_EXT = 1000148029 | |
| 750 VK_BLEND_OP_HARDMIX_EXT = 1000148030 | |
| 751 VK_BLEND_OP_HSL_HUE_EXT = 1000148031 | |
| 752 VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032 | |
| 753 VK_BLEND_OP_HSL_COLOR_EXT = 1000148033 | |
| 754 VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034 | |
| 755 VK_BLEND_OP_PLUS_EXT = 1000148035 | |
| 756 VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036 | |
| 757 VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037 | |
| 758 VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038 | |
| 759 VK_BLEND_OP_MINUS_EXT = 1000148039 | |
| 760 VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040 | |
| 761 VK_BLEND_OP_CONTRAST_EXT = 1000148041 | |
| 762 VK_BLEND_OP_INVERT_OVG_EXT = 1000148042 | |
| 763 VK_BLEND_OP_RED_EXT = 1000148043 | |
| 764 VK_BLEND_OP_GREEN_EXT = 1000148044 | |
| 765 VK_BLEND_OP_BLUE_EXT = 1000148045 | |
| 766 VkStencilOp* {.size: sizeof(cint).} = enum | |
| 767 VK_STENCIL_OP_KEEP = 0 | |
| 768 VK_STENCIL_OP_ZERO = 1 | |
| 769 VK_STENCIL_OP_REPLACE = 2 | |
| 770 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3 | |
| 771 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4 | |
| 772 VK_STENCIL_OP_INVERT = 5 | |
| 773 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6 | |
| 774 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7 | |
| 775 VkLogicOp* {.size: sizeof(cint).} = enum | |
| 776 VK_LOGIC_OP_CLEAR = 0 | |
| 777 VK_LOGIC_OP_AND = 1 | |
| 778 VK_LOGIC_OP_AND_REVERSE = 2 | |
| 779 VK_LOGIC_OP_COPY = 3 | |
| 780 VK_LOGIC_OP_AND_INVERTED = 4 | |
| 781 VK_LOGIC_OP_NO_OP = 5 | |
| 782 VK_LOGIC_OP_XOR = 6 | |
| 783 VK_LOGIC_OP_OR = 7 | |
| 784 VK_LOGIC_OP_NOR = 8 | |
| 785 VK_LOGIC_OP_EQUIVALENT = 9 | |
| 786 VK_LOGIC_OP_INVERT = 10 | |
| 787 VK_LOGIC_OP_OR_REVERSE = 11 | |
| 788 VK_LOGIC_OP_COPY_INVERTED = 12 | |
| 789 VK_LOGIC_OP_OR_INVERTED = 13 | |
| 790 VK_LOGIC_OP_NAND = 14 | |
| 791 VK_LOGIC_OP_SET = 15 | |
| 792 VkInternalAllocationType* {.size: sizeof(cint).} = enum | |
| 793 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0 | |
| 794 VkSystemAllocationScope* {.size: sizeof(cint).} = enum | |
| 795 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0 | |
| 796 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1 | |
| 797 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2 | |
| 798 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3 | |
| 799 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4 | |
| 800 VkPhysicalDeviceType* {.size: sizeof(cint).} = enum | |
| 801 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0 | |
| 802 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1 | |
| 803 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2 | |
| 804 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3 | |
| 805 VK_PHYSICAL_DEVICE_TYPE_CPU = 4 | |
| 806 VkVertexInputRate* {.size: sizeof(cint).} = enum | |
| 807 VK_VERTEX_INPUT_RATE_VERTEX = 0 | |
| 808 VK_VERTEX_INPUT_RATE_INSTANCE = 1 | |
| 809 VkFormat* {.size: sizeof(cint).} = enum | |
| 810 VK_FORMAT_UNDEFINED = 0 | |
| 811 VK_FORMAT_R4G4_UNORM_PACK8 = 1 | |
| 812 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2 | |
| 813 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3 | |
| 814 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4 | |
| 815 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5 | |
| 816 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6 | |
| 817 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7 | |
| 818 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8 | |
| 819 VK_FORMAT_R8_UNORM = 9 | |
| 820 VK_FORMAT_R8_SNORM = 10 | |
| 821 VK_FORMAT_R8_USCALED = 11 | |
| 822 VK_FORMAT_R8_SSCALED = 12 | |
| 823 VK_FORMAT_R8_UINT = 13 | |
| 824 VK_FORMAT_R8_SINT = 14 | |
| 825 VK_FORMAT_R8_SRGB = 15 | |
| 826 VK_FORMAT_R8G8_UNORM = 16 | |
| 827 VK_FORMAT_R8G8_SNORM = 17 | |
| 828 VK_FORMAT_R8G8_USCALED = 18 | |
| 829 VK_FORMAT_R8G8_SSCALED = 19 | |
| 830 VK_FORMAT_R8G8_UINT = 20 | |
| 831 VK_FORMAT_R8G8_SINT = 21 | |
| 832 VK_FORMAT_R8G8_SRGB = 22 | |
| 833 VK_FORMAT_R8G8B8_UNORM = 23 | |
| 834 VK_FORMAT_R8G8B8_SNORM = 24 | |
| 835 VK_FORMAT_R8G8B8_USCALED = 25 | |
| 836 VK_FORMAT_R8G8B8_SSCALED = 26 | |
| 837 VK_FORMAT_R8G8B8_UINT = 27 | |
| 838 VK_FORMAT_R8G8B8_SINT = 28 | |
| 839 VK_FORMAT_R8G8B8_SRGB = 29 | |
| 840 VK_FORMAT_B8G8R8_UNORM = 30 | |
| 841 VK_FORMAT_B8G8R8_SNORM = 31 | |
| 842 VK_FORMAT_B8G8R8_USCALED = 32 | |
| 843 VK_FORMAT_B8G8R8_SSCALED = 33 | |
| 844 VK_FORMAT_B8G8R8_UINT = 34 | |
| 845 VK_FORMAT_B8G8R8_SINT = 35 | |
| 846 VK_FORMAT_B8G8R8_SRGB = 36 | |
| 847 VK_FORMAT_R8G8B8A8_UNORM = 37 | |
| 848 VK_FORMAT_R8G8B8A8_SNORM = 38 | |
| 849 VK_FORMAT_R8G8B8A8_USCALED = 39 | |
| 850 VK_FORMAT_R8G8B8A8_SSCALED = 40 | |
| 851 VK_FORMAT_R8G8B8A8_UINT = 41 | |
| 852 VK_FORMAT_R8G8B8A8_SINT = 42 | |
| 853 VK_FORMAT_R8G8B8A8_SRGB = 43 | |
| 854 VK_FORMAT_B8G8R8A8_UNORM = 44 | |
| 855 VK_FORMAT_B8G8R8A8_SNORM = 45 | |
| 856 VK_FORMAT_B8G8R8A8_USCALED = 46 | |
| 857 VK_FORMAT_B8G8R8A8_SSCALED = 47 | |
| 858 VK_FORMAT_B8G8R8A8_UINT = 48 | |
| 859 VK_FORMAT_B8G8R8A8_SINT = 49 | |
| 860 VK_FORMAT_B8G8R8A8_SRGB = 50 | |
| 861 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51 | |
| 862 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52 | |
| 863 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53 | |
| 864 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54 | |
| 865 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55 | |
| 866 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56 | |
| 867 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57 | |
| 868 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58 | |
| 869 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59 | |
| 870 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60 | |
| 871 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61 | |
| 872 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62 | |
| 873 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63 | |
| 874 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64 | |
| 875 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65 | |
| 876 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66 | |
| 877 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67 | |
| 878 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68 | |
| 879 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69 | |
| 880 VK_FORMAT_R16_UNORM = 70 | |
| 881 VK_FORMAT_R16_SNORM = 71 | |
| 882 VK_FORMAT_R16_USCALED = 72 | |
| 883 VK_FORMAT_R16_SSCALED = 73 | |
| 884 VK_FORMAT_R16_UINT = 74 | |
| 885 VK_FORMAT_R16_SINT = 75 | |
| 886 VK_FORMAT_R16_SFLOAT = 76 | |
| 887 VK_FORMAT_R16G16_UNORM = 77 | |
| 888 VK_FORMAT_R16G16_SNORM = 78 | |
| 889 VK_FORMAT_R16G16_USCALED = 79 | |
| 890 VK_FORMAT_R16G16_SSCALED = 80 | |
| 891 VK_FORMAT_R16G16_UINT = 81 | |
| 892 VK_FORMAT_R16G16_SINT = 82 | |
| 893 VK_FORMAT_R16G16_SFLOAT = 83 | |
| 894 VK_FORMAT_R16G16B16_UNORM = 84 | |
| 895 VK_FORMAT_R16G16B16_SNORM = 85 | |
| 896 VK_FORMAT_R16G16B16_USCALED = 86 | |
| 897 VK_FORMAT_R16G16B16_SSCALED = 87 | |
| 898 VK_FORMAT_R16G16B16_UINT = 88 | |
| 899 VK_FORMAT_R16G16B16_SINT = 89 | |
| 900 VK_FORMAT_R16G16B16_SFLOAT = 90 | |
| 901 VK_FORMAT_R16G16B16A16_UNORM = 91 | |
| 902 VK_FORMAT_R16G16B16A16_SNORM = 92 | |
| 903 VK_FORMAT_R16G16B16A16_USCALED = 93 | |
| 904 VK_FORMAT_R16G16B16A16_SSCALED = 94 | |
| 905 VK_FORMAT_R16G16B16A16_UINT = 95 | |
| 906 VK_FORMAT_R16G16B16A16_SINT = 96 | |
| 907 VK_FORMAT_R16G16B16A16_SFLOAT = 97 | |
| 908 VK_FORMAT_R32_UINT = 98 | |
| 909 VK_FORMAT_R32_SINT = 99 | |
| 910 VK_FORMAT_R32_SFLOAT = 100 | |
| 911 VK_FORMAT_R32G32_UINT = 101 | |
| 912 VK_FORMAT_R32G32_SINT = 102 | |
| 913 VK_FORMAT_R32G32_SFLOAT = 103 | |
| 914 VK_FORMAT_R32G32B32_UINT = 104 | |
| 915 VK_FORMAT_R32G32B32_SINT = 105 | |
| 916 VK_FORMAT_R32G32B32_SFLOAT = 106 | |
| 917 VK_FORMAT_R32G32B32A32_UINT = 107 | |
| 918 VK_FORMAT_R32G32B32A32_SINT = 108 | |
| 919 VK_FORMAT_R32G32B32A32_SFLOAT = 109 | |
| 920 VK_FORMAT_R64_UINT = 110 | |
| 921 VK_FORMAT_R64_SINT = 111 | |
| 922 VK_FORMAT_R64_SFLOAT = 112 | |
| 923 VK_FORMAT_R64G64_UINT = 113 | |
| 924 VK_FORMAT_R64G64_SINT = 114 | |
| 925 VK_FORMAT_R64G64_SFLOAT = 115 | |
| 926 VK_FORMAT_R64G64B64_UINT = 116 | |
| 927 VK_FORMAT_R64G64B64_SINT = 117 | |
| 928 VK_FORMAT_R64G64B64_SFLOAT = 118 | |
| 929 VK_FORMAT_R64G64B64A64_UINT = 119 | |
| 930 VK_FORMAT_R64G64B64A64_SINT = 120 | |
| 931 VK_FORMAT_R64G64B64A64_SFLOAT = 121 | |
| 932 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122 | |
| 933 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123 | |
| 934 VK_FORMAT_D16_UNORM = 124 | |
| 935 VK_FORMAT_X8_D24_UNORM_PACK32 = 125 | |
| 936 VK_FORMAT_D32_SFLOAT = 126 | |
| 937 VK_FORMAT_S8_UINT = 127 | |
| 938 VK_FORMAT_D16_UNORM_S8_UINT = 128 | |
| 939 VK_FORMAT_D24_UNORM_S8_UINT = 129 | |
| 940 VK_FORMAT_D32_SFLOAT_S8_UINT = 130 | |
| 941 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131 | |
| 942 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132 | |
| 943 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133 | |
| 944 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134 | |
| 945 VK_FORMAT_BC2_UNORM_BLOCK = 135 | |
| 946 VK_FORMAT_BC2_SRGB_BLOCK = 136 | |
| 947 VK_FORMAT_BC3_UNORM_BLOCK = 137 | |
| 948 VK_FORMAT_BC3_SRGB_BLOCK = 138 | |
| 949 VK_FORMAT_BC4_UNORM_BLOCK = 139 | |
| 950 VK_FORMAT_BC4_SNORM_BLOCK = 140 | |
| 951 VK_FORMAT_BC5_UNORM_BLOCK = 141 | |
| 952 VK_FORMAT_BC5_SNORM_BLOCK = 142 | |
| 953 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143 | |
| 954 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144 | |
| 955 VK_FORMAT_BC7_UNORM_BLOCK = 145 | |
| 956 VK_FORMAT_BC7_SRGB_BLOCK = 146 | |
| 957 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147 | |
| 958 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148 | |
| 959 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149 | |
| 960 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150 | |
| 961 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151 | |
| 962 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152 | |
| 963 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153 | |
| 964 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154 | |
| 965 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155 | |
| 966 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156 | |
| 967 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157 | |
| 968 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158 | |
| 969 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159 | |
| 970 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160 | |
| 971 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161 | |
| 972 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162 | |
| 973 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163 | |
| 974 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164 | |
| 975 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165 | |
| 976 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166 | |
| 977 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167 | |
| 978 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168 | |
| 979 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169 | |
| 980 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170 | |
| 981 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171 | |
| 982 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172 | |
| 983 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173 | |
| 984 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174 | |
| 985 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175 | |
| 986 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176 | |
| 987 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177 | |
| 988 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178 | |
| 989 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179 | |
| 990 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180 | |
| 991 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181 | |
| 992 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182 | |
| 993 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183 | |
| 994 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184 | |
| 995 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000 | |
| 996 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001 | |
| 997 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002 | |
| 998 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003 | |
| 999 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004 | |
| 1000 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005 | |
| 1001 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006 | |
| 1002 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007 | |
| 1003 VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000 | |
| 1004 VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001 | |
| 1005 VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002 | |
| 1006 VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003 | |
| 1007 VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004 | |
| 1008 VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005 | |
| 1009 VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006 | |
| 1010 VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007 | |
| 1011 VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008 | |
| 1012 VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009 | |
| 1013 VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010 | |
| 1014 VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011 | |
| 1015 VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012 | |
| 1016 VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013 | |
| 1017 VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000 | |
| 1018 VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001 | |
| 1019 VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002 | |
| 1020 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003 | |
| 1021 VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004 | |
| 1022 VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005 | |
| 1023 VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006 | |
| 1024 VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007 | |
| 1025 VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008 | |
| 1026 VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009 | |
| 1027 VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010 | |
| 1028 VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011 | |
| 1029 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012 | |
| 1030 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013 | |
| 1031 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014 | |
| 1032 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015 | |
| 1033 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016 | |
| 1034 VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017 | |
| 1035 VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018 | |
| 1036 VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019 | |
| 1037 VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020 | |
| 1038 VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021 | |
| 1039 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022 | |
| 1040 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023 | |
| 1041 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024 | |
| 1042 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025 | |
| 1043 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026 | |
| 1044 VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027 | |
| 1045 VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028 | |
| 1046 VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029 | |
| 1047 VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030 | |
| 1048 VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031 | |
| 1049 VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032 | |
| 1050 VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033 | |
| 1051 VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT = 1000288000 | |
| 1052 VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT = 1000288001 | |
| 1053 VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT = 1000288002 | |
| 1054 VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT = 1000288003 | |
| 1055 VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT = 1000288004 | |
| 1056 VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT = 1000288005 | |
| 1057 VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT = 1000288006 | |
| 1058 VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT = 1000288007 | |
| 1059 VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT = 1000288008 | |
| 1060 VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT = 1000288009 | |
| 1061 VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT = 1000288010 | |
| 1062 VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT = 1000288011 | |
| 1063 VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT = 1000288012 | |
| 1064 VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT = 1000288013 | |
| 1065 VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT = 1000288014 | |
| 1066 VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT = 1000288015 | |
| 1067 VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT = 1000288016 | |
| 1068 VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT = 1000288017 | |
| 1069 VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT = 1000288018 | |
| 1070 VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT = 1000288019 | |
| 1071 VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT = 1000288020 | |
| 1072 VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT = 1000288021 | |
| 1073 VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT = 1000288022 | |
| 1074 VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT = 1000288023 | |
| 1075 VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT = 1000288024 | |
| 1076 VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT = 1000288025 | |
| 1077 VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT = 1000288026 | |
| 1078 VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT = 1000288027 | |
| 1079 VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT = 1000288028 | |
| 1080 VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT = 1000288029 | |
| 1081 VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000 | |
| 1082 VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001 | |
| 1083 VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002 | |
| 1084 VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003 | |
| 1085 VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000 | |
| 1086 VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001 | |
| 1087 VK_FORMAT_R16G16_S10_5_NV = 1000464000 | |
| 1088 VkStructureType* {.size: sizeof(cint).} = enum | |
| 1089 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0 | |
| 1090 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1 | |
| 1091 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2 | |
| 1092 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3 | |
| 1093 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4 | |
| 1094 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5 | |
| 1095 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6 | |
| 1096 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7 | |
| 1097 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8 | |
| 1098 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9 | |
| 1099 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10 | |
| 1100 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11 | |
| 1101 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12 | |
| 1102 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13 | |
| 1103 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14 | |
| 1104 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15 | |
| 1105 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16 | |
| 1106 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17 | |
| 1107 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18 | |
| 1108 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19 | |
| 1109 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20 | |
| 1110 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21 | |
| 1111 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22 | |
| 1112 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23 | |
| 1113 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24 | |
| 1114 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25 | |
| 1115 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26 | |
| 1116 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27 | |
| 1117 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28 | |
| 1118 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29 | |
| 1119 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30 | |
| 1120 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31 | |
| 1121 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32 | |
| 1122 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33 | |
| 1123 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34 | |
| 1124 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35 | |
| 1125 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36 | |
| 1126 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37 | |
| 1127 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38 | |
| 1128 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39 | |
| 1129 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40 | |
| 1130 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41 | |
| 1131 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42 | |
| 1132 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43 | |
| 1133 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44 | |
| 1134 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45 | |
| 1135 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46 | |
| 1136 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47 | |
| 1137 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48 | |
| 1138 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49 | |
| 1139 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50 | |
| 1140 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51 | |
| 1141 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52 | |
| 1142 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53 | |
| 1143 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54 | |
| 1144 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000 | |
| 1145 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001 | |
| 1146 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000 | |
| 1147 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001 | |
| 1148 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000 | |
| 1149 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000 | |
| 1150 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000 | |
| 1151 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000 | |
| 1152 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000 | |
| 1153 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000 | |
| 1154 VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID = 1000010000 | |
| 1155 VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID = 1000010001 | |
| 1156 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID = 1000010002 | |
| 1157 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000 | |
| 1158 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000 | |
| 1159 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000 | |
| 1160 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001 | |
| 1161 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002 | |
| 1162 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000 | |
| 1163 VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001 | |
| 1164 VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002 | |
| 1165 VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003 | |
| 1166 VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004 | |
| 1167 VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005 | |
| 1168 VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006 | |
| 1169 VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007 | |
| 1170 VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008 | |
| 1171 VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009 | |
| 1172 VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010 | |
| 1173 VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011 | |
| 1174 VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012 | |
| 1175 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013 | |
| 1176 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014 | |
| 1177 VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015 | |
| 1178 VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016 | |
| 1179 VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000 | |
| 1180 VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001 | |
| 1181 VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002 | |
| 1182 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000 | |
| 1183 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001 | |
| 1184 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002 | |
| 1185 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000 | |
| 1186 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001 | |
| 1187 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002 | |
| 1188 VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000 | |
| 1189 VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001 | |
| 1190 VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002 | |
| 1191 VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000 | |
| 1192 VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001 | |
| 1193 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000 | |
| 1194 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001 | |
| 1195 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002 | |
| 1196 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003 | |
| 1197 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004 | |
| 1198 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005 | |
| 1199 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000038006 | |
| 1200 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007 | |
| 1201 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008 | |
| 1202 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009 | |
| 1203 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT = 1000038010 | |
| 1204 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000 | |
| 1205 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001 | |
| 1206 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002 | |
| 1207 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003 | |
| 1208 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004 | |
| 1209 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005 | |
| 1210 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000039006 | |
| 1211 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007 | |
| 1212 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT = 1000039008 | |
| 1213 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009 | |
| 1214 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010 | |
| 1215 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000 | |
| 1216 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001 | |
| 1217 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003 | |
| 1218 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004 | |
| 1219 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005 | |
| 1220 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006 | |
| 1221 VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000 | |
| 1222 VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000 | |
| 1223 VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001 | |
| 1224 VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002 | |
| 1225 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003 | |
| 1226 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004 | |
| 1227 VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006 | |
| 1228 VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007 | |
| 1229 VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008 | |
| 1230 VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009 | |
| 1231 VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000 | |
| 1232 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000 | |
| 1233 VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_RESERVED_OFFSET_0_NV = 1000051000 | |
| 1234 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000 | |
| 1235 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001 | |
| 1236 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002 | |
| 1237 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000 | |
| 1238 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001 | |
| 1239 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000 | |
| 1240 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001 | |
| 1241 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000 | |
| 1242 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000 | |
| 1243 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001 | |
| 1244 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002 | |
| 1245 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003 | |
| 1246 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004 | |
| 1247 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005 | |
| 1248 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006 | |
| 1249 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007 | |
| 1250 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008 | |
| 1251 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000 | |
| 1252 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003 | |
| 1253 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004 | |
| 1254 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005 | |
| 1255 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006 | |
| 1256 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007 | |
| 1257 VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008 | |
| 1258 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009 | |
| 1259 VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010 | |
| 1260 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011 | |
| 1261 VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012 | |
| 1262 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013 | |
| 1263 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014 | |
| 1264 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000 | |
| 1265 VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000 | |
| 1266 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000 | |
| 1267 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000 | |
| 1268 VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000 | |
| 1269 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001 | |
| 1270 VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000 | |
| 1271 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001 | |
| 1272 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002 | |
| 1273 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000 | |
| 1274 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001 | |
| 1275 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000 | |
| 1276 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001 | |
| 1277 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002 | |
| 1278 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003 | |
| 1279 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004 | |
| 1280 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000 | |
| 1281 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001 | |
| 1282 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002 | |
| 1283 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000 | |
| 1284 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001 | |
| 1285 VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002 | |
| 1286 VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003 | |
| 1287 VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000 | |
| 1288 VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001 | |
| 1289 VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002 | |
| 1290 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000 | |
| 1291 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000 | |
| 1292 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001 | |
| 1293 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000 | |
| 1294 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000 | |
| 1295 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001 | |
| 1296 VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002 | |
| 1297 VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003 | |
| 1298 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000 | |
| 1299 VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001 | |
| 1300 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000 | |
| 1301 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000 | |
| 1302 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001 | |
| 1303 VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002 | |
| 1304 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000 | |
| 1305 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000 | |
| 1306 VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000 | |
| 1307 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000 | |
| 1308 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000 | |
| 1309 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000 | |
| 1310 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000 | |
| 1311 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001 | |
| 1312 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002 | |
| 1313 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003 | |
| 1314 VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000 | |
| 1315 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000 | |
| 1316 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000 | |
| 1317 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000 | |
| 1318 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000 | |
| 1319 VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001 | |
| 1320 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000 | |
| 1321 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001 | |
| 1322 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000 | |
| 1323 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001 | |
| 1324 VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000 | |
| 1325 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000 | |
| 1326 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001 | |
| 1327 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002 | |
| 1328 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003 | |
| 1329 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000 | |
| 1330 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001 | |
| 1331 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002 | |
| 1332 VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003 | |
| 1333 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004 | |
| 1334 VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005 | |
| 1335 VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006 | |
| 1336 VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000 | |
| 1337 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000 | |
| 1338 VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001 | |
| 1339 VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000 | |
| 1340 VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000 | |
| 1341 VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001 | |
| 1342 VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002 | |
| 1343 VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000 | |
| 1344 VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001 | |
| 1345 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000 | |
| 1346 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001 | |
| 1347 VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002 | |
| 1348 VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003 | |
| 1349 VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004 | |
| 1350 VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005 | |
| 1351 VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006 | |
| 1352 VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR = 1000116007 | |
| 1353 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000 | |
| 1354 VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001 | |
| 1355 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002 | |
| 1356 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003 | |
| 1357 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000 | |
| 1358 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001 | |
| 1359 VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002 | |
| 1360 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000 | |
| 1361 VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000 | |
| 1362 VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001 | |
| 1363 VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002 | |
| 1364 VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003 | |
| 1365 VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004 | |
| 1366 VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000 | |
| 1367 VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000 | |
| 1368 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000 | |
| 1369 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001 | |
| 1370 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000 | |
| 1371 VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001 | |
| 1372 VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002 | |
| 1373 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003 | |
| 1374 VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004 | |
| 1375 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000 | |
| 1376 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001 | |
| 1377 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002 | |
| 1378 VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003 | |
| 1379 VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004 | |
| 1380 VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005 | |
| 1381 VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006 | |
| 1382 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000 | |
| 1383 VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001 | |
| 1384 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000 | |
| 1385 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001 | |
| 1386 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002 | |
| 1387 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003 | |
| 1388 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000 | |
| 1389 VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001 | |
| 1390 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002 | |
| 1391 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003 | |
| 1392 VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004 | |
| 1393 VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000 | |
| 1394 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001 | |
| 1395 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002 | |
| 1396 VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003 | |
| 1397 VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000 | |
| 1398 VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001 | |
| 1399 VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002 | |
| 1400 VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003 | |
| 1401 VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004 | |
| 1402 VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000 | |
| 1403 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000 | |
| 1404 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001 | |
| 1405 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002 | |
| 1406 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000 | |
| 1407 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000 | |
| 1408 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002 | |
| 1409 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003 | |
| 1410 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004 | |
| 1411 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005 | |
| 1412 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006 | |
| 1413 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007 | |
| 1414 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009 | |
| 1415 VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010 | |
| 1416 VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011 | |
| 1417 VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012 | |
| 1418 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013 | |
| 1419 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014 | |
| 1420 VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015 | |
| 1421 VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016 | |
| 1422 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017 | |
| 1423 VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018 | |
| 1424 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020 | |
| 1425 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000 | |
| 1426 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000 | |
| 1427 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001 | |
| 1428 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000 | |
| 1429 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001 | |
| 1430 VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002 | |
| 1431 VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003 | |
| 1432 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004 | |
| 1433 VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005 | |
| 1434 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000 | |
| 1435 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001 | |
| 1436 VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000 | |
| 1437 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002 | |
| 1438 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003 | |
| 1439 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004 | |
| 1440 VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005 | |
| 1441 VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006 | |
| 1442 VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000 | |
| 1443 VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001 | |
| 1444 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000 | |
| 1445 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001 | |
| 1446 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002 | |
| 1447 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003 | |
| 1448 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004 | |
| 1449 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000 | |
| 1450 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001 | |
| 1451 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000 | |
| 1452 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001 | |
| 1453 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002 | |
| 1454 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005 | |
| 1455 VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000 | |
| 1456 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001 | |
| 1457 VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003 | |
| 1458 VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004 | |
| 1459 VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005 | |
| 1460 VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006 | |
| 1461 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007 | |
| 1462 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008 | |
| 1463 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009 | |
| 1464 VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011 | |
| 1465 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012 | |
| 1466 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000 | |
| 1467 VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001 | |
| 1468 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000 | |
| 1469 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001 | |
| 1470 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000 | |
| 1471 VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001 | |
| 1472 VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000 | |
| 1473 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000 | |
| 1474 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000 | |
| 1475 VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000 | |
| 1476 VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001 | |
| 1477 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002 | |
| 1478 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000 | |
| 1479 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000 | |
| 1480 VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000 | |
| 1481 VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000 | |
| 1482 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000 | |
| 1483 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000 | |
| 1484 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001 | |
| 1485 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002 | |
| 1486 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003 | |
| 1487 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004 | |
| 1488 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005 | |
| 1489 VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000 | |
| 1490 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000 | |
| 1491 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001 | |
| 1492 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002 | |
| 1493 VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000 | |
| 1494 VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000 | |
| 1495 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000 | |
| 1496 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000 | |
| 1497 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000 | |
| 1498 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001 | |
| 1499 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000 | |
| 1500 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000 | |
| 1501 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001 | |
| 1502 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000 | |
| 1503 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000 | |
| 1504 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000 | |
| 1505 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002 | |
| 1506 VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000 | |
| 1507 VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001 | |
| 1508 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000 | |
| 1509 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001 | |
| 1510 VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002 | |
| 1511 VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003 | |
| 1512 VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004 | |
| 1513 VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005 | |
| 1514 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000 | |
| 1515 VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000 | |
| 1516 VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001 | |
| 1517 VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002 | |
| 1518 VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003 | |
| 1519 VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004 | |
| 1520 VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005 | |
| 1521 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000 | |
| 1522 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000 | |
| 1523 VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000 | |
| 1524 VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001 | |
| 1525 VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000 | |
| 1526 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000 | |
| 1527 VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000 | |
| 1528 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000 | |
| 1529 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001 | |
| 1530 VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002 | |
| 1531 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000 | |
| 1532 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000 | |
| 1533 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001 | |
| 1534 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002 | |
| 1535 VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000 | |
| 1536 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001 | |
| 1537 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002 | |
| 1538 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003 | |
| 1539 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004 | |
| 1540 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000 | |
| 1541 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000 | |
| 1542 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000 | |
| 1543 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000 | |
| 1544 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000 | |
| 1545 VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001 | |
| 1546 VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000 | |
| 1547 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000 | |
| 1548 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000 | |
| 1549 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001 | |
| 1550 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002 | |
| 1551 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000 | |
| 1552 VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001 | |
| 1553 VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002 | |
| 1554 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000 | |
| 1555 VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000 | |
| 1556 VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000 | |
| 1557 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000 | |
| 1558 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000 | |
| 1559 VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001 | |
| 1560 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002 | |
| 1561 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000 | |
| 1562 VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001 | |
| 1563 VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002 | |
| 1564 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000 | |
| 1565 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000 | |
| 1566 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000 | |
| 1567 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000 | |
| 1568 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001 | |
| 1569 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002 | |
| 1570 VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000 | |
| 1571 VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001 | |
| 1572 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002 | |
| 1573 VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000 | |
| 1574 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000 | |
| 1575 VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002 | |
| 1576 VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003 | |
| 1577 VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004 | |
| 1578 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000 | |
| 1579 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001 | |
| 1580 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002 | |
| 1581 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000 | |
| 1582 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000 | |
| 1583 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000 | |
| 1584 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000 | |
| 1585 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000 | |
| 1586 VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001 | |
| 1587 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002 | |
| 1588 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003 | |
| 1589 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004 | |
| 1590 VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005 | |
| 1591 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000 | |
| 1592 VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000 | |
| 1593 VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001 | |
| 1594 VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002 | |
| 1595 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000 | |
| 1596 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001 | |
| 1597 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002 | |
| 1598 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003 | |
| 1599 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004 | |
| 1600 VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005 | |
| 1601 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000 | |
| 1602 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000 | |
| 1603 VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001 | |
| 1604 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002 | |
| 1605 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003 | |
| 1606 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004 | |
| 1607 VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005 | |
| 1608 VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006 | |
| 1609 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007 | |
| 1610 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000 | |
| 1611 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001 | |
| 1612 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000 | |
| 1613 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001 | |
| 1614 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000 | |
| 1615 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001 | |
| 1616 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000 | |
| 1617 VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001 | |
| 1618 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000 | |
| 1619 VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001 | |
| 1620 VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002 | |
| 1621 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000 | |
| 1622 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001 | |
| 1623 VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000 | |
| 1624 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001 | |
| 1625 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002 | |
| 1626 VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000 | |
| 1627 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000 | |
| 1628 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001 | |
| 1629 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002 | |
| 1630 VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000 | |
| 1631 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001 | |
| 1632 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000 | |
| 1633 VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001 | |
| 1634 VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002 | |
| 1635 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000 | |
| 1636 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES = 1000298000 | |
| 1637 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES = 1000298001 | |
| 1638 VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO = 1000298002 | |
| 1639 VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO = 1000298003 | |
| 1640 VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION = 1000298004 | |
| 1641 VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE = 1000298005 | |
| 1642 VK_STRUCTURE_TYPE_FAULT_DATA = 1000298007 | |
| 1643 VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO = 1000298008 | |
| 1644 VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO = 1000298010 | |
| 1645 VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000 | |
| 1646 VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001 | |
| 1647 VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002 | |
| 1648 VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003 | |
| 1649 VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004 | |
| 1650 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000 | |
| 1651 VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001 | |
| 1652 VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR = 1000308000 | |
| 1653 VK_STRUCTURE_TYPE_RESERVED_QCOM = 1000309000 | |
| 1654 VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000 | |
| 1655 VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001 | |
| 1656 VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002 | |
| 1657 VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003 | |
| 1658 VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004 | |
| 1659 VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005 | |
| 1660 VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006 | |
| 1661 VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007 | |
| 1662 VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008 | |
| 1663 VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009 | |
| 1664 VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010 | |
| 1665 VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011 | |
| 1666 VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000 | |
| 1667 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001 | |
| 1668 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002 | |
| 1669 VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003 | |
| 1670 VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004 | |
| 1671 VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005 | |
| 1672 VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006 | |
| 1673 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007 | |
| 1674 VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008 | |
| 1675 VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009 | |
| 1676 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000 | |
| 1677 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001 | |
| 1678 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002 | |
| 1679 VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003 | |
| 1680 VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004 | |
| 1681 VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005 | |
| 1682 VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006 | |
| 1683 VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007 | |
| 1684 VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008 | |
| 1685 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009 | |
| 1686 VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010 | |
| 1687 VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011 | |
| 1688 VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012 | |
| 1689 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000 | |
| 1690 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001 | |
| 1691 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002 | |
| 1692 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000 | |
| 1693 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000 | |
| 1694 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000 | |
| 1695 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000 | |
| 1696 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000 | |
| 1697 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001 | |
| 1698 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002 | |
| 1699 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000 | |
| 1700 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001 | |
| 1701 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002 | |
| 1702 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000 | |
| 1703 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001 | |
| 1704 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000 | |
| 1705 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000 | |
| 1706 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001 | |
| 1707 VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000 | |
| 1708 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000 | |
| 1709 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000 | |
| 1710 VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000 | |
| 1711 VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001 | |
| 1712 VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002 | |
| 1713 VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003 | |
| 1714 VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004 | |
| 1715 VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005 | |
| 1716 VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006 | |
| 1717 VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007 | |
| 1718 VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008 | |
| 1719 VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009 | |
| 1720 VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010 | |
| 1721 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000 | |
| 1722 VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001 | |
| 1723 VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = 1000338002 | |
| 1724 VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = 1000338003 | |
| 1725 VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004 | |
| 1726 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000 | |
| 1727 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000 | |
| 1728 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000 | |
| 1729 VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001 | |
| 1730 VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002 | |
| 1731 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000 | |
| 1732 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000 | |
| 1733 VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000 | |
| 1734 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000 | |
| 1735 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001 | |
| 1736 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013 | |
| 1737 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000 | |
| 1738 VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002 | |
| 1739 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000 | |
| 1740 VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001 | |
| 1741 VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002 | |
| 1742 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000 | |
| 1743 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000 | |
| 1744 VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001 | |
| 1745 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000 | |
| 1746 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001 | |
| 1747 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000 | |
| 1748 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000 | |
| 1749 VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000 | |
| 1750 VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001 | |
| 1751 VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002 | |
| 1752 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000 | |
| 1753 VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001 | |
| 1754 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000 | |
| 1755 VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001 | |
| 1756 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002 | |
| 1757 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003 | |
| 1758 VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004 | |
| 1759 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005 | |
| 1760 VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006 | |
| 1761 VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007 | |
| 1762 VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008 | |
| 1763 VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009 | |
| 1764 VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000 | |
| 1765 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001 | |
| 1766 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002 | |
| 1767 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000 | |
| 1768 VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000 | |
| 1769 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001 | |
| 1770 VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000 | |
| 1771 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001 | |
| 1772 VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV = 1000373000 | |
| 1773 VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV = 1000373001 | |
| 1774 VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV = 1000373002 | |
| 1775 VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV = 1000373003 | |
| 1776 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV = 1000373004 | |
| 1777 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV = 1000373005 | |
| 1778 VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV = 1000373006 | |
| 1779 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV = 1000373007 | |
| 1780 VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV = 1000374000 | |
| 1781 VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV = 1000374001 | |
| 1782 VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV = 1000374002 | |
| 1783 VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV = 1000374003 | |
| 1784 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV = 1000374004 | |
| 1785 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000 | |
| 1786 VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001 | |
| 1787 VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002 | |
| 1788 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000 | |
| 1789 VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000 | |
| 1790 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000 | |
| 1791 VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001 | |
| 1792 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000 | |
| 1793 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000 | |
| 1794 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000 | |
| 1795 VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001 | |
| 1796 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000 | |
| 1797 VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001 | |
| 1798 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000 | |
| 1799 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001 | |
| 1800 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000 | |
| 1801 VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000 | |
| 1802 VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001 | |
| 1803 VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002 | |
| 1804 VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003 | |
| 1805 VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004 | |
| 1806 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005 | |
| 1807 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006 | |
| 1808 VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007 | |
| 1809 VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008 | |
| 1810 VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009 | |
| 1811 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000 | |
| 1812 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001 | |
| 1813 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000 | |
| 1814 VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001 | |
| 1815 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000 | |
| 1816 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000 | |
| 1817 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001 | |
| 1818 VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002 | |
| 1819 VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003 | |
| 1820 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000 | |
| 1821 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000 | |
| 1822 VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001 | |
| 1823 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000 | |
| 1824 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001 | |
| 1825 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002 | |
| 1826 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000 | |
| 1827 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000 | |
| 1828 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000 | |
| 1829 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001 | |
| 1830 VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002 | |
| 1831 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000 | |
| 1832 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001 | |
| 1833 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000 | |
| 1834 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001 | |
| 1835 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000 | |
| 1836 VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT = 1000435000 | |
| 1837 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000 | |
| 1838 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000 | |
| 1839 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001 | |
| 1840 VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002 | |
| 1841 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000 | |
| 1842 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001 | |
| 1843 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000 | |
| 1844 VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001 | |
| 1845 VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002 | |
| 1846 VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003 | |
| 1847 VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000 | |
| 1848 VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001 | |
| 1849 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000 | |
| 1850 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001 | |
| 1851 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002 | |
| 1852 VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003 | |
| 1853 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000 | |
| 1854 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001 | |
| 1855 VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002 | |
| 1856 VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003 | |
| 1857 VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004 | |
| 1858 VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005 | |
| 1859 VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010 | |
| 1860 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000 | |
| 1861 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000 | |
| 1862 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000 | |
| 1863 VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001 | |
| 1864 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000 | |
| 1865 VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001 | |
| 1866 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000 | |
| 1867 VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV = 1000489000 | |
| 1868 VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV = 1000489001 | |
| 1869 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV = 1000489002 | |
| 1870 VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV = 1000489003 | |
| 1871 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000 | |
| 1872 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001 | |
| 1873 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000 | |
| 1874 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001 | |
| 1875 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000 | |
| 1876 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000 | |
| 1877 VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001 | |
| 1878 VkSubpassContents* {.size: sizeof(cint).} = enum | |
| 1879 VK_SUBPASS_CONTENTS_INLINE = 0 | |
| 1880 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1 | |
| 1881 VkResult* {.size: sizeof(cint).} = enum | |
| 1882 VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000 | |
| 1883 VK_ERROR_NO_PIPELINE_MATCH = -1000298001 | |
| 1884 VK_ERROR_INVALID_PIPELINE_CACHE_DATA = -1000298000 | |
| 1885 VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000 | |
| 1886 VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000 | |
| 1887 VK_ERROR_NOT_PERMITTED_KHR = -1000174001 | |
| 1888 VK_ERROR_FRAGMENTATION = -1000161000 | |
| 1889 VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000 | |
| 1890 VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003 | |
| 1891 VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000 | |
| 1892 VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005 | |
| 1893 VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004 | |
| 1894 VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003 | |
| 1895 VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002 | |
| 1896 VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001 | |
| 1897 VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000 | |
| 1898 VK_ERROR_INVALID_SHADER_NV = -1000012000 | |
| 1899 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001 | |
| 1900 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001 | |
| 1901 VK_ERROR_OUT_OF_DATE_KHR = -1000001004 | |
| 1902 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001 | |
| 1903 VK_ERROR_SURFACE_LOST_KHR = -1000000000 | |
| 1904 VK_ERROR_UNKNOWN = -13 | |
| 1905 VK_ERROR_FRAGMENTED_POOL = -12 | |
| 1906 VK_ERROR_FORMAT_NOT_SUPPORTED = -11 | |
| 1907 VK_ERROR_TOO_MANY_OBJECTS = -10 | |
| 1908 VK_ERROR_INCOMPATIBLE_DRIVER = -9 | |
| 1909 VK_ERROR_FEATURE_NOT_PRESENT = -8 | |
| 1910 VK_ERROR_EXTENSION_NOT_PRESENT = -7 | |
| 1911 VK_ERROR_LAYER_NOT_PRESENT = -6 | |
| 1912 VK_ERROR_MEMORY_MAP_FAILED = -5 | |
| 1913 VK_ERROR_DEVICE_LOST = -4 | |
| 1914 VK_ERROR_INITIALIZATION_FAILED = -3 | |
| 1915 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2 | |
| 1916 VK_ERROR_OUT_OF_HOST_MEMORY = -1 | |
| 1917 VK_SUCCESS = 0 | |
| 1918 VK_NOT_READY = 1 | |
| 1919 VK_TIMEOUT = 2 | |
| 1920 VK_EVENT_SET = 3 | |
| 1921 VK_EVENT_RESET = 4 | |
| 1922 VK_INCOMPLETE = 5 | |
| 1923 VK_SUBOPTIMAL_KHR = 1000001003 | |
| 1924 VK_THREAD_IDLE_KHR = 1000268000 | |
| 1925 VK_THREAD_DONE_KHR = 1000268001 | |
| 1926 VK_OPERATION_DEFERRED_KHR = 1000268002 | |
| 1927 VK_OPERATION_NOT_DEFERRED_KHR = 1000268003 | |
| 1928 VK_PIPELINE_COMPILE_REQUIRED = 1000297000 | |
| 1929 VkDynamicState* {.size: sizeof(cint).} = enum | |
| 1930 VK_DYNAMIC_STATE_VIEWPORT = 0 | |
| 1931 VK_DYNAMIC_STATE_SCISSOR = 1 | |
| 1932 VK_DYNAMIC_STATE_LINE_WIDTH = 2 | |
| 1933 VK_DYNAMIC_STATE_DEPTH_BIAS = 3 | |
| 1934 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4 | |
| 1935 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5 | |
| 1936 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6 | |
| 1937 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7 | |
| 1938 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8 | |
| 1939 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000 | |
| 1940 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000 | |
| 1941 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001 | |
| 1942 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002 | |
| 1943 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000 | |
| 1944 VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004 | |
| 1945 VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006 | |
| 1946 VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000 | |
| 1947 VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001 | |
| 1948 VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000 | |
| 1949 VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000 | |
| 1950 VK_DYNAMIC_STATE_CULL_MODE = 1000267000 | |
| 1951 VK_DYNAMIC_STATE_FRONT_FACE = 1000267001 | |
| 1952 VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002 | |
| 1953 VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003 | |
| 1954 VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004 | |
| 1955 VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005 | |
| 1956 VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006 | |
| 1957 VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007 | |
| 1958 VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008 | |
| 1959 VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009 | |
| 1960 VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010 | |
| 1961 VK_DYNAMIC_STATE_STENCIL_OP = 1000267011 | |
| 1962 VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000 | |
| 1963 VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000 | |
| 1964 VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000 | |
| 1965 VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001 | |
| 1966 VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002 | |
| 1967 VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003 | |
| 1968 VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004 | |
| 1969 VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000 | |
| 1970 VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002 | |
| 1971 VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003 | |
| 1972 VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004 | |
| 1973 VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005 | |
| 1974 VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006 | |
| 1975 VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007 | |
| 1976 VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008 | |
| 1977 VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009 | |
| 1978 VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010 | |
| 1979 VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011 | |
| 1980 VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012 | |
| 1981 VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013 | |
| 1982 VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014 | |
| 1983 VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015 | |
| 1984 VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016 | |
| 1985 VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017 | |
| 1986 VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018 | |
| 1987 VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019 | |
| 1988 VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020 | |
| 1989 VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021 | |
| 1990 VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022 | |
| 1991 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023 | |
| 1992 VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024 | |
| 1993 VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025 | |
| 1994 VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026 | |
| 1995 VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027 | |
| 1996 VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028 | |
| 1997 VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029 | |
| 1998 VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030 | |
| 1999 VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031 | |
| 2000 VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032 | |
| 2001 VkDescriptorUpdateTemplateType* {.size: sizeof(cint).} = enum | |
| 2002 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0 | |
| 2003 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1 | |
| 2004 VkObjectType* {.size: sizeof(cint).} = enum | |
| 2005 VK_OBJECT_TYPE_UNKNOWN = 0 | |
| 2006 VK_OBJECT_TYPE_INSTANCE = 1 | |
| 2007 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2 | |
| 2008 VK_OBJECT_TYPE_DEVICE = 3 | |
| 2009 VK_OBJECT_TYPE_QUEUE = 4 | |
| 2010 VK_OBJECT_TYPE_SEMAPHORE = 5 | |
| 2011 VK_OBJECT_TYPE_COMMAND_BUFFER = 6 | |
| 2012 VK_OBJECT_TYPE_FENCE = 7 | |
| 2013 VK_OBJECT_TYPE_DEVICE_MEMORY = 8 | |
| 2014 VK_OBJECT_TYPE_BUFFER = 9 | |
| 2015 VK_OBJECT_TYPE_IMAGE = 10 | |
| 2016 VK_OBJECT_TYPE_EVENT = 11 | |
| 2017 VK_OBJECT_TYPE_QUERY_POOL = 12 | |
| 2018 VK_OBJECT_TYPE_BUFFER_VIEW = 13 | |
| 2019 VK_OBJECT_TYPE_IMAGE_VIEW = 14 | |
| 2020 VK_OBJECT_TYPE_SHADER_MODULE = 15 | |
| 2021 VK_OBJECT_TYPE_PIPELINE_CACHE = 16 | |
| 2022 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17 | |
| 2023 VK_OBJECT_TYPE_RENDER_PASS = 18 | |
| 2024 VK_OBJECT_TYPE_PIPELINE = 19 | |
| 2025 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20 | |
| 2026 VK_OBJECT_TYPE_SAMPLER = 21 | |
| 2027 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22 | |
| 2028 VK_OBJECT_TYPE_DESCRIPTOR_SET = 23 | |
| 2029 VK_OBJECT_TYPE_FRAMEBUFFER = 24 | |
| 2030 VK_OBJECT_TYPE_COMMAND_POOL = 25 | |
| 2031 VK_OBJECT_TYPE_SURFACE_KHR = 1000000000 | |
| 2032 VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000 | |
| 2033 VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000 | |
| 2034 VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001 | |
| 2035 VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000 | |
| 2036 VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000 | |
| 2037 VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001 | |
| 2038 VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000 | |
| 2039 VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001 | |
| 2040 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000 | |
| 2041 VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000 | |
| 2042 VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000 | |
| 2043 VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000 | |
| 2044 VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000 | |
| 2045 VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000 | |
| 2046 VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000 | |
| 2047 VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000 | |
| 2048 VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000 | |
| 2049 VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000 | |
| 2050 VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000 | |
| 2051 VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000 | |
| 2052 VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000 | |
| 2053 VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV = 1000489000 | |
| 2054 VkRayTracingInvocationReorderModeNV* {.size: sizeof(cint).} = enum | |
| 2055 VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0 | |
| 2056 VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1 | |
| 2057 VkDirectDriverLoadingModeLUNARG* {.size: sizeof(cint).} = enum | |
| 2058 VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0 | |
| 2059 VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1 | |
| 2060 VkQueueFlagBits* {.size: sizeof(cint).} = enum | |
| 2061 VK_QUEUE_GRAPHICS_BIT = 0b00000000000000000000000000000001 | |
| 2062 VK_QUEUE_COMPUTE_BIT = 0b00000000000000000000000000000010 | |
| 2063 VK_QUEUE_TRANSFER_BIT = 0b00000000000000000000000000000100 | |
| 2064 VK_QUEUE_SPARSE_BINDING_BIT = 0b00000000000000000000000000001000 | |
| 2065 VK_QUEUE_PROTECTED_BIT = 0b00000000000000000000000000010000 | |
| 2066 VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0b00000000000000000000000000100000 | |
| 2067 VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0b00000000000000000000000001000000 | |
| 2068 VK_QUEUE_RESERVED_7_BIT_QCOM = 0b00000000000000000000000010000000 | |
| 2069 VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0b00000000000000000000000100000000 | |
| 2070 VK_QUEUE_RESERVED_9_BIT_EXT = 0b00000000000000000000001000000000 | |
| 2071 func toBits*(flags: openArray[VkQueueFlagBits]): VkQueueFlags = | |
| 2072 for flag in flags: | |
| 2073 result = VkQueueFlags(uint(result) or uint(flag)) | |
| 2074 func toEnums*(number: VkQueueFlags): seq[VkQueueFlagBits] = | |
| 2075 for value in VkQueueFlagBits.items: | |
| 2076 if (value.ord and cint(number)) > 0: | |
| 2077 result.add value | |
| 2078 proc `==`*(a, b: VkQueueFlags): bool = cint(a) == cint(b) | |
| 2079 type | |
| 2080 VkCullModeFlagBits* {.size: sizeof(cint).} = enum | |
| 2081 VK_CULL_MODE_FRONT_BIT = 0b00000000000000000000000000000001 | |
| 2082 VK_CULL_MODE_BACK_BIT = 0b00000000000000000000000000000010 | |
| 2083 func toBits*(flags: openArray[VkCullModeFlagBits]): VkCullModeFlags = | |
| 2084 for flag in flags: | |
| 2085 result = VkCullModeFlags(uint(result) or uint(flag)) | |
| 2086 func toEnums*(number: VkCullModeFlags): seq[VkCullModeFlagBits] = | |
| 2087 for value in VkCullModeFlagBits.items: | |
| 2088 if (value.ord and cint(number)) > 0: | |
| 2089 result.add value | |
| 2090 proc `==`*(a, b: VkCullModeFlags): bool = cint(a) == cint(b) | |
| 2091 const | |
| 2092 VK_CULL_MODE_NONE* = 0 | |
| 2093 VK_CULL_MODE_FRONT_AND_BACK* = 0x00000003 | |
| 2094 type | |
| 2095 VkRenderPassCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2096 VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR = 0b00000000000000000000000000000001 | |
| 2097 VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0b00000000000000000000000000000010 | |
| 2098 func toBits*(flags: openArray[VkRenderPassCreateFlagBits]): VkRenderPassCreateFlags = | |
| 2099 for flag in flags: | |
| 2100 result = VkRenderPassCreateFlags(uint(result) or uint(flag)) | |
| 2101 func toEnums*(number: VkRenderPassCreateFlags): seq[VkRenderPassCreateFlagBits] = | |
| 2102 for value in VkRenderPassCreateFlagBits.items: | |
| 2103 if (value.ord and cint(number)) > 0: | |
| 2104 result.add value | |
| 2105 proc `==`*(a, b: VkRenderPassCreateFlags): bool = cint(a) == cint(b) | |
| 2106 type | |
| 2107 VkDeviceQueueCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2108 VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0b00000000000000000000000000000001 | |
| 2109 VK_DEVICE_QUEUE_CREATE_RESERVED_1_BIT_QCOM = 0b00000000000000000000000000000010 | |
| 2110 func toBits*(flags: openArray[VkDeviceQueueCreateFlagBits]): VkDeviceQueueCreateFlags = | |
| 2111 for flag in flags: | |
| 2112 result = VkDeviceQueueCreateFlags(uint(result) or uint(flag)) | |
| 2113 func toEnums*(number: VkDeviceQueueCreateFlags): seq[VkDeviceQueueCreateFlagBits] = | |
| 2114 for value in VkDeviceQueueCreateFlagBits.items: | |
| 2115 if (value.ord and cint(number)) > 0: | |
| 2116 result.add value | |
| 2117 proc `==`*(a, b: VkDeviceQueueCreateFlags): bool = cint(a) == cint(b) | |
| 2118 type | |
| 2119 VkMemoryPropertyFlagBits* {.size: sizeof(cint).} = enum | |
| 2120 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0b00000000000000000000000000000001 | |
| 2121 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0b00000000000000000000000000000010 | |
| 2122 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0b00000000000000000000000000000100 | |
| 2123 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0b00000000000000000000000000001000 | |
| 2124 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0b00000000000000000000000000010000 | |
| 2125 VK_MEMORY_PROPERTY_PROTECTED_BIT = 0b00000000000000000000000000100000 | |
| 2126 VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0b00000000000000000000000001000000 | |
| 2127 VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0b00000000000000000000000010000000 | |
| 2128 VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0b00000000000000000000000100000000 | |
| 2129 func toBits*(flags: openArray[VkMemoryPropertyFlagBits]): VkMemoryPropertyFlags = | |
| 2130 for flag in flags: | |
| 2131 result = VkMemoryPropertyFlags(uint(result) or uint(flag)) | |
| 2132 func toEnums*(number: VkMemoryPropertyFlags): seq[VkMemoryPropertyFlagBits] = | |
| 2133 for value in VkMemoryPropertyFlagBits.items: | |
| 2134 if (value.ord and cint(number)) > 0: | |
| 2135 result.add value | |
| 2136 proc `==`*(a, b: VkMemoryPropertyFlags): bool = cint(a) == cint(b) | |
| 2137 type | |
| 2138 VkMemoryHeapFlagBits* {.size: sizeof(cint).} = enum | |
| 2139 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0b00000000000000000000000000000001 | |
| 2140 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0b00000000000000000000000000000010 | |
| 2141 VK_MEMORY_HEAP_SEU_SAFE_BIT = 0b00000000000000000000000000000100 | |
| 2142 func toBits*(flags: openArray[VkMemoryHeapFlagBits]): VkMemoryHeapFlags = | |
| 2143 for flag in flags: | |
| 2144 result = VkMemoryHeapFlags(uint(result) or uint(flag)) | |
| 2145 func toEnums*(number: VkMemoryHeapFlags): seq[VkMemoryHeapFlagBits] = | |
| 2146 for value in VkMemoryHeapFlagBits.items: | |
| 2147 if (value.ord and cint(number)) > 0: | |
| 2148 result.add value | |
| 2149 proc `==`*(a, b: VkMemoryHeapFlags): bool = cint(a) == cint(b) | |
| 2150 type | |
| 2151 VkAccessFlagBits* {.size: sizeof(cint).} = enum | |
| 2152 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0b00000000000000000000000000000001 | |
| 2153 VK_ACCESS_INDEX_READ_BIT = 0b00000000000000000000000000000010 | |
| 2154 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0b00000000000000000000000000000100 | |
| 2155 VK_ACCESS_UNIFORM_READ_BIT = 0b00000000000000000000000000001000 | |
| 2156 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0b00000000000000000000000000010000 | |
| 2157 VK_ACCESS_SHADER_READ_BIT = 0b00000000000000000000000000100000 | |
| 2158 VK_ACCESS_SHADER_WRITE_BIT = 0b00000000000000000000000001000000 | |
| 2159 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0b00000000000000000000000010000000 | |
| 2160 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0b00000000000000000000000100000000 | |
| 2161 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0b00000000000000000000001000000000 | |
| 2162 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0b00000000000000000000010000000000 | |
| 2163 VK_ACCESS_TRANSFER_READ_BIT = 0b00000000000000000000100000000000 | |
| 2164 VK_ACCESS_TRANSFER_WRITE_BIT = 0b00000000000000000001000000000000 | |
| 2165 VK_ACCESS_HOST_READ_BIT = 0b00000000000000000010000000000000 | |
| 2166 VK_ACCESS_HOST_WRITE_BIT = 0b00000000000000000100000000000000 | |
| 2167 VK_ACCESS_MEMORY_READ_BIT = 0b00000000000000001000000000000000 | |
| 2168 VK_ACCESS_MEMORY_WRITE_BIT = 0b00000000000000010000000000000000 | |
| 2169 VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0b00000000000000100000000000000000 | |
| 2170 VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0b00000000000001000000000000000000 | |
| 2171 VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0b00000000000010000000000000000000 | |
| 2172 VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0b00000000000100000000000000000000 | |
| 2173 VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0b00000000001000000000000000000000 | |
| 2174 VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0b00000000010000000000000000000000 | |
| 2175 VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0b00000000100000000000000000000000 | |
| 2176 VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0b00000001000000000000000000000000 | |
| 2177 VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0b00000010000000000000000000000000 | |
| 2178 VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0b00000100000000000000000000000000 | |
| 2179 VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0b00001000000000000000000000000000 | |
| 2180 func toBits*(flags: openArray[VkAccessFlagBits]): VkAccessFlags = | |
| 2181 for flag in flags: | |
| 2182 result = VkAccessFlags(uint(result) or uint(flag)) | |
| 2183 func toEnums*(number: VkAccessFlags): seq[VkAccessFlagBits] = | |
| 2184 for value in VkAccessFlagBits.items: | |
| 2185 if (value.ord and cint(number)) > 0: | |
| 2186 result.add value | |
| 2187 proc `==`*(a, b: VkAccessFlags): bool = cint(a) == cint(b) | |
| 2188 type | |
| 2189 VkBufferUsageFlagBits* {.size: sizeof(cint).} = enum | |
| 2190 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0b00000000000000000000000000000001 | |
| 2191 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0b00000000000000000000000000000010 | |
| 2192 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0b00000000000000000000000000000100 | |
| 2193 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0b00000000000000000000000000001000 | |
| 2194 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0b00000000000000000000000000010000 | |
| 2195 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0b00000000000000000000000000100000 | |
| 2196 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0b00000000000000000000000001000000 | |
| 2197 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0b00000000000000000000000010000000 | |
| 2198 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0b00000000000000000000000100000000 | |
| 2199 VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0b00000000000000000000001000000000 | |
| 2200 VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0b00000000000000000000010000000000 | |
| 2201 VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0b00000000000000000000100000000000 | |
| 2202 VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0b00000000000000000001000000000000 | |
| 2203 VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0b00000000000000000010000000000000 | |
| 2204 VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0b00000000000000000100000000000000 | |
| 2205 VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0b00000000000000001000000000000000 | |
| 2206 VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0b00000000000000010000000000000000 | |
| 2207 VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0b00000000000000100000000000000000 | |
| 2208 VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM = 0b00000000000001000000000000000000 | |
| 2209 VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0b00000000000010000000000000000000 | |
| 2210 VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0b00000000000100000000000000000000 | |
| 2211 VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000000001000000000000000000000 | |
| 2212 VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000000010000000000000000000000 | |
| 2213 VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0b00000000100000000000000000000000 | |
| 2214 VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0b00000001000000000000000000000000 | |
| 2215 VK_BUFFER_USAGE_RESERVED_25_BIT_AMD = 0b00000010000000000000000000000000 | |
| 2216 VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000100000000000000000000000000 | |
| 2217 func toBits*(flags: openArray[VkBufferUsageFlagBits]): VkBufferUsageFlags = | |
| 2218 for flag in flags: | |
| 2219 result = VkBufferUsageFlags(uint(result) or uint(flag)) | |
| 2220 func toEnums*(number: VkBufferUsageFlags): seq[VkBufferUsageFlagBits] = | |
| 2221 for value in VkBufferUsageFlagBits.items: | |
| 2222 if (value.ord and cint(number)) > 0: | |
| 2223 result.add value | |
| 2224 proc `==`*(a, b: VkBufferUsageFlags): bool = cint(a) == cint(b) | |
| 2225 type | |
| 2226 VkBufferCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2227 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0b00000000000000000000000000000001 | |
| 2228 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0b00000000000000000000000000000010 | |
| 2229 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0b00000000000000000000000000000100 | |
| 2230 VK_BUFFER_CREATE_PROTECTED_BIT = 0b00000000000000000000000000001000 | |
| 2231 VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0b00000000000000000000000000010000 | |
| 2232 VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000100000 | |
| 2233 func toBits*(flags: openArray[VkBufferCreateFlagBits]): VkBufferCreateFlags = | |
| 2234 for flag in flags: | |
| 2235 result = VkBufferCreateFlags(uint(result) or uint(flag)) | |
| 2236 func toEnums*(number: VkBufferCreateFlags): seq[VkBufferCreateFlagBits] = | |
| 2237 for value in VkBufferCreateFlagBits.items: | |
| 2238 if (value.ord and cint(number)) > 0: | |
| 2239 result.add value | |
| 2240 proc `==`*(a, b: VkBufferCreateFlags): bool = cint(a) == cint(b) | |
| 2241 type | |
| 2242 VkShaderStageFlagBits* {.size: sizeof(cint).} = enum | |
| 2243 VK_SHADER_STAGE_VERTEX_BIT = 0b00000000000000000000000000000001 | |
| 2244 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0b00000000000000000000000000000010 | |
| 2245 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0b00000000000000000000000000000100 | |
| 2246 VK_SHADER_STAGE_GEOMETRY_BIT = 0b00000000000000000000000000001000 | |
| 2247 VK_SHADER_STAGE_FRAGMENT_BIT = 0b00000000000000000000000000010000 | |
| 2248 VK_SHADER_STAGE_COMPUTE_BIT = 0b00000000000000000000000000100000 | |
| 2249 VK_SHADER_STAGE_TASK_BIT_EXT = 0b00000000000000000000000001000000 | |
| 2250 VK_SHADER_STAGE_MESH_BIT_EXT = 0b00000000000000000000000010000000 | |
| 2251 VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0b00000000000000000000000100000000 | |
| 2252 VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0b00000000000000000000001000000000 | |
| 2253 VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0b00000000000000000000010000000000 | |
| 2254 VK_SHADER_STAGE_MISS_BIT_KHR = 0b00000000000000000000100000000000 | |
| 2255 VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0b00000000000000000001000000000000 | |
| 2256 VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0b00000000000000000010000000000000 | |
| 2257 VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0b00000000000000000100000000000000 | |
| 2258 VK_SHADER_STAGE_EXT_483_RESERVE_15 = 0b00000000000000001000000000000000 | |
| 2259 VK_SHADER_STAGE_EXT_483_RESERVE_16 = 0b00000000000000010000000000000000 | |
| 2260 VK_SHADER_STAGE_EXT_483_RESERVE_17 = 0b00000000000000100000000000000000 | |
| 2261 VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0b00000000000010000000000000000000 | |
| 2262 func toBits*(flags: openArray[VkShaderStageFlagBits]): VkShaderStageFlags = | |
| 2263 for flag in flags: | |
| 2264 result = VkShaderStageFlags(uint(result) or uint(flag)) | |
| 2265 func toEnums*(number: VkShaderStageFlags): seq[VkShaderStageFlagBits] = | |
| 2266 for value in VkShaderStageFlagBits.items: | |
| 2267 if (value.ord and cint(number)) > 0: | |
| 2268 result.add value | |
| 2269 proc `==`*(a, b: VkShaderStageFlags): bool = cint(a) == cint(b) | |
| 2270 const | |
| 2271 VK_SHADER_STAGE_ALL_GRAPHICS* = 0x0000001F | |
| 2272 VK_SHADER_STAGE_ALL* = 0x7FFFFFFF | |
| 2273 type | |
| 2274 VkImageUsageFlagBits* {.size: sizeof(cint).} = enum | |
| 2275 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0b00000000000000000000000000000001 | |
| 2276 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0b00000000000000000000000000000010 | |
| 2277 VK_IMAGE_USAGE_SAMPLED_BIT = 0b00000000000000000000000000000100 | |
| 2278 VK_IMAGE_USAGE_STORAGE_BIT = 0b00000000000000000000000000001000 | |
| 2279 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0b00000000000000000000000000010000 | |
| 2280 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0b00000000000000000000000000100000 | |
| 2281 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0b00000000000000000000000001000000 | |
| 2282 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0b00000000000000000000000010000000 | |
| 2283 VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b00000000000000000000000100000000 | |
| 2284 VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0b00000000000000000000001000000000 | |
| 2285 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0b00000000000000000000010000000000 | |
| 2286 VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0b00000000000000000000100000000000 | |
| 2287 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0b00000000000000000001000000000000 | |
| 2288 VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0b00000000000000000010000000000000 | |
| 2289 VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0b00000000000000000100000000000000 | |
| 2290 VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0b00000000000000001000000000000000 | |
| 2291 VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM = 0b00000000000000010000000000000000 | |
| 2292 VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM = 0b00000000000000100000000000000000 | |
| 2293 VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0b00000000000001000000000000000000 | |
| 2294 VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0b00000000000010000000000000000000 | |
| 2295 VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0b00000000000100000000000000000000 | |
| 2296 VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0b00000000001000000000000000000000 | |
| 2297 VK_IMAGE_USAGE_RESERVED_22_BIT_EXT = 0b00000000010000000000000000000000 | |
| 2298 func toBits*(flags: openArray[VkImageUsageFlagBits]): VkImageUsageFlags = | |
| 2299 for flag in flags: | |
| 2300 result = VkImageUsageFlags(uint(result) or uint(flag)) | |
| 2301 func toEnums*(number: VkImageUsageFlags): seq[VkImageUsageFlagBits] = | |
| 2302 for value in VkImageUsageFlagBits.items: | |
| 2303 if (value.ord and cint(number)) > 0: | |
| 2304 result.add value | |
| 2305 proc `==`*(a, b: VkImageUsageFlags): bool = cint(a) == cint(b) | |
| 2306 type | |
| 2307 VkImageCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2308 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0b00000000000000000000000000000001 | |
| 2309 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0b00000000000000000000000000000010 | |
| 2310 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0b00000000000000000000000000000100 | |
| 2311 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0b00000000000000000000000000001000 | |
| 2312 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0b00000000000000000000000000010000 | |
| 2313 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0b00000000000000000000000000100000 | |
| 2314 VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0b00000000000000000000000001000000 | |
| 2315 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0b00000000000000000000000010000000 | |
| 2316 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0b00000000000000000000000100000000 | |
| 2317 VK_IMAGE_CREATE_DISJOINT_BIT = 0b00000000000000000000001000000000 | |
| 2318 VK_IMAGE_CREATE_ALIAS_BIT = 0b00000000000000000000010000000000 | |
| 2319 VK_IMAGE_CREATE_PROTECTED_BIT = 0b00000000000000000000100000000000 | |
| 2320 VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0b00000000000000000001000000000000 | |
| 2321 VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0b00000000000000000010000000000000 | |
| 2322 VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0b00000000000000000100000000000000 | |
| 2323 VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0b00000000000000001000000000000000 | |
| 2324 VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000010000000000000000 | |
| 2325 VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0b00000000000000100000000000000000 | |
| 2326 VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0b00000000000001000000000000000000 | |
| 2327 VK_IMAGE_CREATE_RESERVED_19_BIT_EXT = 0b00000000000010000000000000000000 | |
| 2328 func toBits*(flags: openArray[VkImageCreateFlagBits]): VkImageCreateFlags = | |
| 2329 for flag in flags: | |
| 2330 result = VkImageCreateFlags(uint(result) or uint(flag)) | |
| 2331 func toEnums*(number: VkImageCreateFlags): seq[VkImageCreateFlagBits] = | |
| 2332 for value in VkImageCreateFlagBits.items: | |
| 2333 if (value.ord and cint(number)) > 0: | |
| 2334 result.add value | |
| 2335 proc `==`*(a, b: VkImageCreateFlags): bool = cint(a) == cint(b) | |
| 2336 type | |
| 2337 VkImageViewCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2338 VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0b00000000000000000000000000000001 | |
| 2339 VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0b00000000000000000000000000000010 | |
| 2340 VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000000100 | |
| 2341 func toBits*(flags: openArray[VkImageViewCreateFlagBits]): VkImageViewCreateFlags = | |
| 2342 for flag in flags: | |
| 2343 result = VkImageViewCreateFlags(uint(result) or uint(flag)) | |
| 2344 func toEnums*(number: VkImageViewCreateFlags): seq[VkImageViewCreateFlagBits] = | |
| 2345 for value in VkImageViewCreateFlagBits.items: | |
| 2346 if (value.ord and cint(number)) > 0: | |
| 2347 result.add value | |
| 2348 proc `==`*(a, b: VkImageViewCreateFlags): bool = cint(a) == cint(b) | |
| 2349 type | |
| 2350 VkSamplerCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2351 VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0b00000000000000000000000000000001 | |
| 2352 VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0b00000000000000000000000000000010 | |
| 2353 VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0b00000000000000000000000000000100 | |
| 2354 VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000001000 | |
| 2355 VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0b00000000000000000000000000010000 | |
| 2356 func toBits*(flags: openArray[VkSamplerCreateFlagBits]): VkSamplerCreateFlags = | |
| 2357 for flag in flags: | |
| 2358 result = VkSamplerCreateFlags(uint(result) or uint(flag)) | |
| 2359 func toEnums*(number: VkSamplerCreateFlags): seq[VkSamplerCreateFlagBits] = | |
| 2360 for value in VkSamplerCreateFlagBits.items: | |
| 2361 if (value.ord and cint(number)) > 0: | |
| 2362 result.add value | |
| 2363 proc `==`*(a, b: VkSamplerCreateFlags): bool = cint(a) == cint(b) | |
| 2364 type | |
| 2365 VkPipelineCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2366 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0b00000000000000000000000000000001 | |
| 2367 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0b00000000000000000000000000000010 | |
| 2368 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0b00000000000000000000000000000100 | |
| 2369 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0b00000000000000000000000000001000 | |
| 2370 VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0b00000000000000000000000000010000 | |
| 2371 VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0b00000000000000000000000000100000 | |
| 2372 VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0b00000000000000000000000001000000 | |
| 2373 VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0b00000000000000000000000010000000 | |
| 2374 VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0b00000000000000000000000100000000 | |
| 2375 VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0b00000000000000000000001000000000 | |
| 2376 VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0b00000000000000000000010000000000 | |
| 2377 VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0b00000000000000000000100000000000 | |
| 2378 VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0b00000000000000000001000000000000 | |
| 2379 VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0b00000000000000000010000000000000 | |
| 2380 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0b00000000000000000100000000000000 | |
| 2381 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0b00000000000000001000000000000000 | |
| 2382 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0b00000000000000010000000000000000 | |
| 2383 VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0b00000000000000100000000000000000 | |
| 2384 VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0b00000000000001000000000000000000 | |
| 2385 VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0b00000000000010000000000000000000 | |
| 2386 VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0b00000000000100000000000000000000 | |
| 2387 VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b00000000001000000000000000000000 | |
| 2388 VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0b00000000010000000000000000000000 | |
| 2389 VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0b00000000100000000000000000000000 | |
| 2390 VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0b00000001000000000000000000000000 | |
| 2391 VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0b00000010000000000000000000000000 | |
| 2392 VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0b00000100000000000000000000000000 | |
| 2393 VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0b00001000000000000000000000000000 | |
| 2394 VK_PIPELINE_CREATE_RESERVED_BIT_28_NV = 0b00010000000000000000000000000000 | |
| 2395 VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0b00100000000000000000000000000000 | |
| 2396 VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0b01000000000000000000000000000000 | |
| 2397 func toBits*(flags: openArray[VkPipelineCreateFlagBits]): VkPipelineCreateFlags = | |
| 2398 for flag in flags: | |
| 2399 result = VkPipelineCreateFlags(uint(result) or uint(flag)) | |
| 2400 func toEnums*(number: VkPipelineCreateFlags): seq[VkPipelineCreateFlagBits] = | |
| 2401 for value in VkPipelineCreateFlagBits.items: | |
| 2402 if (value.ord and cint(number)) > 0: | |
| 2403 result.add value | |
| 2404 proc `==`*(a, b: VkPipelineCreateFlags): bool = cint(a) == cint(b) | |
| 2405 type | |
| 2406 VkPipelineShaderStageCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2407 VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0b00000000000000000000000000000001 | |
| 2408 VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0b00000000000000000000000000000010 | |
| 2409 VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR = 0b00000000000000000000000000001000 | |
| 2410 func toBits*(flags: openArray[VkPipelineShaderStageCreateFlagBits]): VkPipelineShaderStageCreateFlags = | |
| 2411 for flag in flags: | |
| 2412 result = VkPipelineShaderStageCreateFlags(uint(result) or uint(flag)) | |
| 2413 func toEnums*(number: VkPipelineShaderStageCreateFlags): seq[VkPipelineShaderStageCreateFlagBits] = | |
| 2414 for value in VkPipelineShaderStageCreateFlagBits.items: | |
| 2415 if (value.ord and cint(number)) > 0: | |
| 2416 result.add value | |
| 2417 proc `==`*(a, b: VkPipelineShaderStageCreateFlags): bool = cint(a) == cint(b) | |
| 2418 type | |
| 2419 VkColorComponentFlagBits* {.size: sizeof(cint).} = enum | |
| 2420 VK_COLOR_COMPONENT_R_BIT = 0b00000000000000000000000000000001 | |
| 2421 VK_COLOR_COMPONENT_G_BIT = 0b00000000000000000000000000000010 | |
| 2422 VK_COLOR_COMPONENT_B_BIT = 0b00000000000000000000000000000100 | |
| 2423 VK_COLOR_COMPONENT_A_BIT = 0b00000000000000000000000000001000 | |
| 2424 func toBits*(flags: openArray[VkColorComponentFlagBits]): VkColorComponentFlags = | |
| 2425 for flag in flags: | |
| 2426 result = VkColorComponentFlags(uint(result) or uint(flag)) | |
| 2427 func toEnums*(number: VkColorComponentFlags): seq[VkColorComponentFlagBits] = | |
| 2428 for value in VkColorComponentFlagBits.items: | |
| 2429 if (value.ord and cint(number)) > 0: | |
| 2430 result.add value | |
| 2431 proc `==`*(a, b: VkColorComponentFlags): bool = cint(a) == cint(b) | |
| 2432 type | |
| 2433 VkFenceCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2434 VK_FENCE_CREATE_SIGNALED_BIT = 0b00000000000000000000000000000001 | |
| 2435 func toBits*(flags: openArray[VkFenceCreateFlagBits]): VkFenceCreateFlags = | |
| 2436 for flag in flags: | |
| 2437 result = VkFenceCreateFlags(uint(result) or uint(flag)) | |
| 2438 func toEnums*(number: VkFenceCreateFlags): seq[VkFenceCreateFlagBits] = | |
| 2439 for value in VkFenceCreateFlagBits.items: | |
| 2440 if (value.ord and cint(number)) > 0: | |
| 2441 result.add value | |
| 2442 proc `==`*(a, b: VkFenceCreateFlags): bool = cint(a) == cint(b) | |
| 2443 type | |
| 2444 VkFormatFeatureFlagBits* {.size: sizeof(cint).} = enum | |
| 2445 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0b00000000000000000000000000000001 | |
| 2446 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0b00000000000000000000000000000010 | |
| 2447 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0b00000000000000000000000000000100 | |
| 2448 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0b00000000000000000000000000001000 | |
| 2449 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0b00000000000000000000000000010000 | |
| 2450 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0b00000000000000000000000000100000 | |
| 2451 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0b00000000000000000000000001000000 | |
| 2452 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0b00000000000000000000000010000000 | |
| 2453 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0b00000000000000000000000100000000 | |
| 2454 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0b00000000000000000000001000000000 | |
| 2455 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0b00000000000000000000010000000000 | |
| 2456 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0b00000000000000000000100000000000 | |
| 2457 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0b00000000000000000001000000000000 | |
| 2458 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0b00000000000000000010000000000000 | |
| 2459 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0b00000000000000000100000000000000 | |
| 2460 VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0b00000000000000001000000000000000 | |
| 2461 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0b00000000000000010000000000000000 | |
| 2462 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0b00000000000000100000000000000000 | |
| 2463 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0b00000000000001000000000000000000 | |
| 2464 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0b00000000000010000000000000000000 | |
| 2465 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0b00000000000100000000000000000000 | |
| 2466 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0b00000000001000000000000000000000 | |
| 2467 VK_FORMAT_FEATURE_DISJOINT_BIT = 0b00000000010000000000000000000000 | |
| 2468 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0b00000000100000000000000000000000 | |
| 2469 VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0b00000001000000000000000000000000 | |
| 2470 VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0b00000010000000000000000000000000 | |
| 2471 VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0b00000100000000000000000000000000 | |
| 2472 VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0b00001000000000000000000000000000 | |
| 2473 VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0b00010000000000000000000000000000 | |
| 2474 VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0b00100000000000000000000000000000 | |
| 2475 VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b01000000000000000000000000000000 | |
| 2476 func toBits*(flags: openArray[VkFormatFeatureFlagBits]): VkFormatFeatureFlags = | |
| 2477 for flag in flags: | |
| 2478 result = VkFormatFeatureFlags(uint(result) or uint(flag)) | |
| 2479 func toEnums*(number: VkFormatFeatureFlags): seq[VkFormatFeatureFlagBits] = | |
| 2480 for value in VkFormatFeatureFlagBits.items: | |
| 2481 if (value.ord and cint(number)) > 0: | |
| 2482 result.add value | |
| 2483 proc `==`*(a, b: VkFormatFeatureFlags): bool = cint(a) == cint(b) | |
| 2484 type | |
| 2485 VkQueryControlFlagBits* {.size: sizeof(cint).} = enum | |
| 2486 VK_QUERY_CONTROL_PRECISE_BIT = 0b00000000000000000000000000000001 | |
| 2487 func toBits*(flags: openArray[VkQueryControlFlagBits]): VkQueryControlFlags = | |
| 2488 for flag in flags: | |
| 2489 result = VkQueryControlFlags(uint(result) or uint(flag)) | |
| 2490 func toEnums*(number: VkQueryControlFlags): seq[VkQueryControlFlagBits] = | |
| 2491 for value in VkQueryControlFlagBits.items: | |
| 2492 if (value.ord and cint(number)) > 0: | |
| 2493 result.add value | |
| 2494 proc `==`*(a, b: VkQueryControlFlags): bool = cint(a) == cint(b) | |
| 2495 type | |
| 2496 VkQueryResultFlagBits* {.size: sizeof(cint).} = enum | |
| 2497 VK_QUERY_RESULT_64_BIT = 0b00000000000000000000000000000001 | |
| 2498 VK_QUERY_RESULT_WAIT_BIT = 0b00000000000000000000000000000010 | |
| 2499 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0b00000000000000000000000000000100 | |
| 2500 VK_QUERY_RESULT_PARTIAL_BIT = 0b00000000000000000000000000001000 | |
| 2501 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0b00000000000000000000000000010000 | |
| 2502 func toBits*(flags: openArray[VkQueryResultFlagBits]): VkQueryResultFlags = | |
| 2503 for flag in flags: | |
| 2504 result = VkQueryResultFlags(uint(result) or uint(flag)) | |
| 2505 func toEnums*(number: VkQueryResultFlags): seq[VkQueryResultFlagBits] = | |
| 2506 for value in VkQueryResultFlagBits.items: | |
| 2507 if (value.ord and cint(number)) > 0: | |
| 2508 result.add value | |
| 2509 proc `==`*(a, b: VkQueryResultFlags): bool = cint(a) == cint(b) | |
| 2510 type | |
| 2511 VkCommandBufferUsageFlagBits* {.size: sizeof(cint).} = enum | |
| 2512 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0b00000000000000000000000000000001 | |
| 2513 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0b00000000000000000000000000000010 | |
| 2514 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0b00000000000000000000000000000100 | |
| 2515 func toBits*(flags: openArray[VkCommandBufferUsageFlagBits]): VkCommandBufferUsageFlags = | |
| 2516 for flag in flags: | |
| 2517 result = VkCommandBufferUsageFlags(uint(result) or uint(flag)) | |
| 2518 func toEnums*(number: VkCommandBufferUsageFlags): seq[VkCommandBufferUsageFlagBits] = | |
| 2519 for value in VkCommandBufferUsageFlagBits.items: | |
| 2520 if (value.ord and cint(number)) > 0: | |
| 2521 result.add value | |
| 2522 proc `==`*(a, b: VkCommandBufferUsageFlags): bool = cint(a) == cint(b) | |
| 2523 type | |
| 2524 VkQueryPipelineStatisticFlagBits* {.size: sizeof(cint).} = enum | |
| 2525 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0b00000000000000000000000000000001 | |
| 2526 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0b00000000000000000000000000000010 | |
| 2527 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0b00000000000000000000000000000100 | |
| 2528 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0b00000000000000000000000000001000 | |
| 2529 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0b00000000000000000000000000010000 | |
| 2530 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0b00000000000000000000000000100000 | |
| 2531 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0b00000000000000000000000001000000 | |
| 2532 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0b00000000000000000000000010000000 | |
| 2533 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0b00000000000000000000000100000000 | |
| 2534 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0b00000000000000000000001000000000 | |
| 2535 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0b00000000000000000000010000000000 | |
| 2536 VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0b00000000000000000000100000000000 | |
| 2537 VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0b00000000000000000001000000000000 | |
| 2538 VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0b00000000000000000010000000000000 | |
| 2539 func toBits*(flags: openArray[VkQueryPipelineStatisticFlagBits]): VkQueryPipelineStatisticFlags = | |
| 2540 for flag in flags: | |
| 2541 result = VkQueryPipelineStatisticFlags(uint(result) or uint(flag)) | |
| 2542 func toEnums*(number: VkQueryPipelineStatisticFlags): seq[VkQueryPipelineStatisticFlagBits] = | |
| 2543 for value in VkQueryPipelineStatisticFlagBits.items: | |
| 2544 if (value.ord and cint(number)) > 0: | |
| 2545 result.add value | |
| 2546 proc `==`*(a, b: VkQueryPipelineStatisticFlags): bool = cint(a) == cint(b) | |
| 2547 type | |
| 2548 VkImageAspectFlagBits* {.size: sizeof(cint).} = enum | |
| 2549 VK_IMAGE_ASPECT_COLOR_BIT = 0b00000000000000000000000000000001 | |
| 2550 VK_IMAGE_ASPECT_DEPTH_BIT = 0b00000000000000000000000000000010 | |
| 2551 VK_IMAGE_ASPECT_STENCIL_BIT = 0b00000000000000000000000000000100 | |
| 2552 VK_IMAGE_ASPECT_METADATA_BIT = 0b00000000000000000000000000001000 | |
| 2553 VK_IMAGE_ASPECT_PLANE_0_BIT = 0b00000000000000000000000000010000 | |
| 2554 VK_IMAGE_ASPECT_PLANE_1_BIT = 0b00000000000000000000000000100000 | |
| 2555 VK_IMAGE_ASPECT_PLANE_2_BIT = 0b00000000000000000000000001000000 | |
| 2556 VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0b00000000000000000000000010000000 | |
| 2557 VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0b00000000000000000000000100000000 | |
| 2558 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0b00000000000000000000001000000000 | |
| 2559 VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0b00000000000000000000010000000000 | |
| 2560 func toBits*(flags: openArray[VkImageAspectFlagBits]): VkImageAspectFlags = | |
| 2561 for flag in flags: | |
| 2562 result = VkImageAspectFlags(uint(result) or uint(flag)) | |
| 2563 func toEnums*(number: VkImageAspectFlags): seq[VkImageAspectFlagBits] = | |
| 2564 for value in VkImageAspectFlagBits.items: | |
| 2565 if (value.ord and cint(number)) > 0: | |
| 2566 result.add value | |
| 2567 proc `==`*(a, b: VkImageAspectFlags): bool = cint(a) == cint(b) | |
| 2568 type | |
| 2569 VkSparseImageFormatFlagBits* {.size: sizeof(cint).} = enum | |
| 2570 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0b00000000000000000000000000000001 | |
| 2571 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0b00000000000000000000000000000010 | |
| 2572 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0b00000000000000000000000000000100 | |
| 2573 func toBits*(flags: openArray[VkSparseImageFormatFlagBits]): VkSparseImageFormatFlags = | |
| 2574 for flag in flags: | |
| 2575 result = VkSparseImageFormatFlags(uint(result) or uint(flag)) | |
| 2576 func toEnums*(number: VkSparseImageFormatFlags): seq[VkSparseImageFormatFlagBits] = | |
| 2577 for value in VkSparseImageFormatFlagBits.items: | |
| 2578 if (value.ord and cint(number)) > 0: | |
| 2579 result.add value | |
| 2580 proc `==`*(a, b: VkSparseImageFormatFlags): bool = cint(a) == cint(b) | |
| 2581 type | |
| 2582 VkSparseMemoryBindFlagBits* {.size: sizeof(cint).} = enum | |
| 2583 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0b00000000000000000000000000000001 | |
| 2584 func toBits*(flags: openArray[VkSparseMemoryBindFlagBits]): VkSparseMemoryBindFlags = | |
| 2585 for flag in flags: | |
| 2586 result = VkSparseMemoryBindFlags(uint(result) or uint(flag)) | |
| 2587 func toEnums*(number: VkSparseMemoryBindFlags): seq[VkSparseMemoryBindFlagBits] = | |
| 2588 for value in VkSparseMemoryBindFlagBits.items: | |
| 2589 if (value.ord and cint(number)) > 0: | |
| 2590 result.add value | |
| 2591 proc `==`*(a, b: VkSparseMemoryBindFlags): bool = cint(a) == cint(b) | |
| 2592 type | |
| 2593 VkPipelineStageFlagBits* {.size: sizeof(cint).} = enum | |
| 2594 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0b00000000000000000000000000000001 | |
| 2595 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0b00000000000000000000000000000010 | |
| 2596 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0b00000000000000000000000000000100 | |
| 2597 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0b00000000000000000000000000001000 | |
| 2598 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0b00000000000000000000000000010000 | |
| 2599 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0b00000000000000000000000000100000 | |
| 2600 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0b00000000000000000000000001000000 | |
| 2601 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0b00000000000000000000000010000000 | |
| 2602 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0b00000000000000000000000100000000 | |
| 2603 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0b00000000000000000000001000000000 | |
| 2604 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0b00000000000000000000010000000000 | |
| 2605 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0b00000000000000000000100000000000 | |
| 2606 VK_PIPELINE_STAGE_TRANSFER_BIT = 0b00000000000000000001000000000000 | |
| 2607 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0b00000000000000000010000000000000 | |
| 2608 VK_PIPELINE_STAGE_HOST_BIT = 0b00000000000000000100000000000000 | |
| 2609 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0b00000000000000001000000000000000 | |
| 2610 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0b00000000000000010000000000000000 | |
| 2611 VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0b00000000000000100000000000000000 | |
| 2612 VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0b00000000000001000000000000000000 | |
| 2613 VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0b00000000000010000000000000000000 | |
| 2614 VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0b00000000000100000000000000000000 | |
| 2615 VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0b00000000001000000000000000000000 | |
| 2616 VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b00000000010000000000000000000000 | |
| 2617 VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0b00000000100000000000000000000000 | |
| 2618 VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0b00000001000000000000000000000000 | |
| 2619 VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0b00000010000000000000000000000000 | |
| 2620 func toBits*(flags: openArray[VkPipelineStageFlagBits]): VkPipelineStageFlags = | |
| 2621 for flag in flags: | |
| 2622 result = VkPipelineStageFlags(uint(result) or uint(flag)) | |
| 2623 func toEnums*(number: VkPipelineStageFlags): seq[VkPipelineStageFlagBits] = | |
| 2624 for value in VkPipelineStageFlagBits.items: | |
| 2625 if (value.ord and cint(number)) > 0: | |
| 2626 result.add value | |
| 2627 proc `==`*(a, b: VkPipelineStageFlags): bool = cint(a) == cint(b) | |
| 2628 type | |
| 2629 VkCommandPoolCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2630 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0b00000000000000000000000000000001 | |
| 2631 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0b00000000000000000000000000000010 | |
| 2632 VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0b00000000000000000000000000000100 | |
| 2633 func toBits*(flags: openArray[VkCommandPoolCreateFlagBits]): VkCommandPoolCreateFlags = | |
| 2634 for flag in flags: | |
| 2635 result = VkCommandPoolCreateFlags(uint(result) or uint(flag)) | |
| 2636 func toEnums*(number: VkCommandPoolCreateFlags): seq[VkCommandPoolCreateFlagBits] = | |
| 2637 for value in VkCommandPoolCreateFlagBits.items: | |
| 2638 if (value.ord and cint(number)) > 0: | |
| 2639 result.add value | |
| 2640 proc `==`*(a, b: VkCommandPoolCreateFlags): bool = cint(a) == cint(b) | |
| 2641 type | |
| 2642 VkCommandPoolResetFlagBits* {.size: sizeof(cint).} = enum | |
| 2643 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0b00000000000000000000000000000001 | |
| 2644 VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI = 0b00000000000000000000000000000010 | |
| 2645 func toBits*(flags: openArray[VkCommandPoolResetFlagBits]): VkCommandPoolResetFlags = | |
| 2646 for flag in flags: | |
| 2647 result = VkCommandPoolResetFlags(uint(result) or uint(flag)) | |
| 2648 func toEnums*(number: VkCommandPoolResetFlags): seq[VkCommandPoolResetFlagBits] = | |
| 2649 for value in VkCommandPoolResetFlagBits.items: | |
| 2650 if (value.ord and cint(number)) > 0: | |
| 2651 result.add value | |
| 2652 proc `==`*(a, b: VkCommandPoolResetFlags): bool = cint(a) == cint(b) | |
| 2653 type | |
| 2654 VkCommandBufferResetFlagBits* {.size: sizeof(cint).} = enum | |
| 2655 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0b00000000000000000000000000000001 | |
| 2656 func toBits*(flags: openArray[VkCommandBufferResetFlagBits]): VkCommandBufferResetFlags = | |
| 2657 for flag in flags: | |
| 2658 result = VkCommandBufferResetFlags(uint(result) or uint(flag)) | |
| 2659 func toEnums*(number: VkCommandBufferResetFlags): seq[VkCommandBufferResetFlagBits] = | |
| 2660 for value in VkCommandBufferResetFlagBits.items: | |
| 2661 if (value.ord and cint(number)) > 0: | |
| 2662 result.add value | |
| 2663 proc `==`*(a, b: VkCommandBufferResetFlags): bool = cint(a) == cint(b) | |
| 2664 type | |
| 2665 VkSampleCountFlagBits* {.size: sizeof(cint).} = enum | |
| 2666 VK_SAMPLE_COUNT_1_BIT = 0b00000000000000000000000000000001 | |
| 2667 VK_SAMPLE_COUNT_2_BIT = 0b00000000000000000000000000000010 | |
| 2668 VK_SAMPLE_COUNT_4_BIT = 0b00000000000000000000000000000100 | |
| 2669 VK_SAMPLE_COUNT_8_BIT = 0b00000000000000000000000000001000 | |
| 2670 VK_SAMPLE_COUNT_16_BIT = 0b00000000000000000000000000010000 | |
| 2671 VK_SAMPLE_COUNT_32_BIT = 0b00000000000000000000000000100000 | |
| 2672 VK_SAMPLE_COUNT_64_BIT = 0b00000000000000000000000001000000 | |
| 2673 func toBits*(flags: openArray[VkSampleCountFlagBits]): VkSampleCountFlags = | |
| 2674 for flag in flags: | |
| 2675 result = VkSampleCountFlags(uint(result) or uint(flag)) | |
| 2676 func toEnums*(number: VkSampleCountFlags): seq[VkSampleCountFlagBits] = | |
| 2677 for value in VkSampleCountFlagBits.items: | |
| 2678 if (value.ord and cint(number)) > 0: | |
| 2679 result.add value | |
| 2680 proc `==`*(a, b: VkSampleCountFlags): bool = cint(a) == cint(b) | |
| 2681 type | |
| 2682 VkAttachmentDescriptionFlagBits* {.size: sizeof(cint).} = enum | |
| 2683 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0b00000000000000000000000000000001 | |
| 2684 func toBits*(flags: openArray[VkAttachmentDescriptionFlagBits]): VkAttachmentDescriptionFlags = | |
| 2685 for flag in flags: | |
| 2686 result = VkAttachmentDescriptionFlags(uint(result) or uint(flag)) | |
| 2687 func toEnums*(number: VkAttachmentDescriptionFlags): seq[VkAttachmentDescriptionFlagBits] = | |
| 2688 for value in VkAttachmentDescriptionFlagBits.items: | |
| 2689 if (value.ord and cint(number)) > 0: | |
| 2690 result.add value | |
| 2691 proc `==`*(a, b: VkAttachmentDescriptionFlags): bool = cint(a) == cint(b) | |
| 2692 type | |
| 2693 VkStencilFaceFlagBits* {.size: sizeof(cint).} = enum | |
| 2694 VK_STENCIL_FACE_FRONT_BIT = 0b00000000000000000000000000000001 | |
| 2695 VK_STENCIL_FACE_BACK_BIT = 0b00000000000000000000000000000010 | |
| 2696 func toBits*(flags: openArray[VkStencilFaceFlagBits]): VkStencilFaceFlags = | |
| 2697 for flag in flags: | |
| 2698 result = VkStencilFaceFlags(uint(result) or uint(flag)) | |
| 2699 func toEnums*(number: VkStencilFaceFlags): seq[VkStencilFaceFlagBits] = | |
| 2700 for value in VkStencilFaceFlagBits.items: | |
| 2701 if (value.ord and cint(number)) > 0: | |
| 2702 result.add value | |
| 2703 proc `==`*(a, b: VkStencilFaceFlags): bool = cint(a) == cint(b) | |
| 2704 const | |
| 2705 VK_STENCIL_FACE_FRONT_AND_BACK* = 0x00000003 | |
| 2706 type | |
| 2707 VkDescriptorPoolCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2708 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0b00000000000000000000000000000001 | |
| 2709 VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0b00000000000000000000000000000010 | |
| 2710 VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0b00000000000000000000000000000100 | |
| 2711 func toBits*(flags: openArray[VkDescriptorPoolCreateFlagBits]): VkDescriptorPoolCreateFlags = | |
| 2712 for flag in flags: | |
| 2713 result = VkDescriptorPoolCreateFlags(uint(result) or uint(flag)) | |
| 2714 func toEnums*(number: VkDescriptorPoolCreateFlags): seq[VkDescriptorPoolCreateFlagBits] = | |
| 2715 for value in VkDescriptorPoolCreateFlagBits.items: | |
| 2716 if (value.ord and cint(number)) > 0: | |
| 2717 result.add value | |
| 2718 proc `==`*(a, b: VkDescriptorPoolCreateFlags): bool = cint(a) == cint(b) | |
| 2719 type | |
| 2720 VkDependencyFlagBits* {.size: sizeof(cint).} = enum | |
| 2721 VK_DEPENDENCY_BY_REGION_BIT = 0b00000000000000000000000000000001 | |
| 2722 VK_DEPENDENCY_VIEW_LOCAL_BIT = 0b00000000000000000000000000000010 | |
| 2723 VK_DEPENDENCY_DEVICE_GROUP_BIT = 0b00000000000000000000000000000100 | |
| 2724 VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0b00000000000000000000000000001000 | |
| 2725 func toBits*(flags: openArray[VkDependencyFlagBits]): VkDependencyFlags = | |
| 2726 for flag in flags: | |
| 2727 result = VkDependencyFlags(uint(result) or uint(flag)) | |
| 2728 func toEnums*(number: VkDependencyFlags): seq[VkDependencyFlagBits] = | |
| 2729 for value in VkDependencyFlagBits.items: | |
| 2730 if (value.ord and cint(number)) > 0: | |
| 2731 result.add value | |
| 2732 proc `==`*(a, b: VkDependencyFlags): bool = cint(a) == cint(b) | |
| 2733 type | |
| 2734 VkSemaphoreType* {.size: sizeof(cint).} = enum | |
| 2735 VK_SEMAPHORE_TYPE_BINARY = 0 | |
| 2736 VK_SEMAPHORE_TYPE_TIMELINE = 1 | |
| 2737 VkSemaphoreWaitFlagBits* {.size: sizeof(cint).} = enum | |
| 2738 VK_SEMAPHORE_WAIT_ANY_BIT = 0b00000000000000000000000000000001 | |
| 2739 func toBits*(flags: openArray[VkSemaphoreWaitFlagBits]): VkSemaphoreWaitFlags = | |
| 2740 for flag in flags: | |
| 2741 result = VkSemaphoreWaitFlags(uint(result) or uint(flag)) | |
| 2742 func toEnums*(number: VkSemaphoreWaitFlags): seq[VkSemaphoreWaitFlagBits] = | |
| 2743 for value in VkSemaphoreWaitFlagBits.items: | |
| 2744 if (value.ord and cint(number)) > 0: | |
| 2745 result.add value | |
| 2746 proc `==`*(a, b: VkSemaphoreWaitFlags): bool = cint(a) == cint(b) | |
| 2747 type | |
| 2748 VkPresentModeKHR* {.size: sizeof(cint).} = enum | |
| 2749 VK_PRESENT_MODE_IMMEDIATE_KHR = 0 | |
| 2750 VK_PRESENT_MODE_MAILBOX_KHR = 1 | |
| 2751 VK_PRESENT_MODE_FIFO_KHR = 2 | |
| 2752 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3 | |
| 2753 VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000 | |
| 2754 VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001 | |
| 2755 VkColorSpaceKHR* {.size: sizeof(cint).} = enum | |
| 2756 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0 | |
| 2757 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001 | |
| 2758 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002 | |
| 2759 VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003 | |
| 2760 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004 | |
| 2761 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005 | |
| 2762 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006 | |
| 2763 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007 | |
| 2764 VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008 | |
| 2765 VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009 | |
| 2766 VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010 | |
| 2767 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011 | |
| 2768 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012 | |
| 2769 VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013 | |
| 2770 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014 | |
| 2771 VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000 | |
| 2772 VkDisplayPlaneAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 2773 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 2774 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0b00000000000000000000000000000010 | |
| 2775 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0b00000000000000000000000000000100 | |
| 2776 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0b00000000000000000000000000001000 | |
| 2777 func toBits*(flags: openArray[VkDisplayPlaneAlphaFlagBitsKHR]): VkDisplayPlaneAlphaFlagsKHR = | |
| 2778 for flag in flags: | |
| 2779 result = VkDisplayPlaneAlphaFlagsKHR(uint(result) or uint(flag)) | |
| 2780 func toEnums*(number: VkDisplayPlaneAlphaFlagsKHR): seq[VkDisplayPlaneAlphaFlagBitsKHR] = | |
| 2781 for value in VkDisplayPlaneAlphaFlagBitsKHR.items: | |
| 2782 if (value.ord and cint(number)) > 0: | |
| 2783 result.add value | |
| 2784 proc `==`*(a, b: VkDisplayPlaneAlphaFlagsKHR): bool = cint(a) == cint(b) | |
| 2785 type | |
| 2786 VkCompositeAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 2787 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 2788 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0b00000000000000000000000000000010 | |
| 2789 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0b00000000000000000000000000000100 | |
| 2790 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0b00000000000000000000000000001000 | |
| 2791 func toBits*(flags: openArray[VkCompositeAlphaFlagBitsKHR]): VkCompositeAlphaFlagsKHR = | |
| 2792 for flag in flags: | |
| 2793 result = VkCompositeAlphaFlagsKHR(uint(result) or uint(flag)) | |
| 2794 func toEnums*(number: VkCompositeAlphaFlagsKHR): seq[VkCompositeAlphaFlagBitsKHR] = | |
| 2795 for value in VkCompositeAlphaFlagBitsKHR.items: | |
| 2796 if (value.ord and cint(number)) > 0: | |
| 2797 result.add value | |
| 2798 proc `==`*(a, b: VkCompositeAlphaFlagsKHR): bool = cint(a) == cint(b) | |
| 2799 type | |
| 2800 VkSurfaceTransformFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 2801 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0b00000000000000000000000000000001 | |
| 2802 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0b00000000000000000000000000000010 | |
| 2803 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0b00000000000000000000000000000100 | |
| 2804 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0b00000000000000000000000000001000 | |
| 2805 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0b00000000000000000000000000010000 | |
| 2806 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0b00000000000000000000000000100000 | |
| 2807 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0b00000000000000000000000001000000 | |
| 2808 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0b00000000000000000000000010000000 | |
| 2809 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0b00000000000000000000000100000000 | |
| 2810 func toBits*(flags: openArray[VkSurfaceTransformFlagBitsKHR]): VkSurfaceTransformFlagsKHR = | |
| 2811 for flag in flags: | |
| 2812 result = VkSurfaceTransformFlagsKHR(uint(result) or uint(flag)) | |
| 2813 func toEnums*(number: VkSurfaceTransformFlagsKHR): seq[VkSurfaceTransformFlagBitsKHR] = | |
| 2814 for value in VkSurfaceTransformFlagBitsKHR.items: | |
| 2815 if (value.ord and cint(number)) > 0: | |
| 2816 result.add value | |
| 2817 proc `==`*(a, b: VkSurfaceTransformFlagsKHR): bool = cint(a) == cint(b) | |
| 2818 type | |
| 2819 VkSwapchainImageUsageFlagBitsANDROID* {.size: sizeof(cint).} = enum | |
| 2820 VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0b00000000000000000000000000000001 | |
| 2821 func toBits*(flags: openArray[VkSwapchainImageUsageFlagBitsANDROID]): VkSwapchainImageUsageFlagsANDROID = | |
| 2822 for flag in flags: | |
| 2823 result = VkSwapchainImageUsageFlagsANDROID(uint(result) or uint(flag)) | |
| 2824 func toEnums*(number: VkSwapchainImageUsageFlagsANDROID): seq[VkSwapchainImageUsageFlagBitsANDROID] = | |
| 2825 for value in VkSwapchainImageUsageFlagBitsANDROID.items: | |
| 2826 if (value.ord and cint(number)) > 0: | |
| 2827 result.add value | |
| 2828 proc `==`*(a, b: VkSwapchainImageUsageFlagsANDROID): bool = cint(a) == cint(b) | |
| 2829 type | |
| 2830 VkTimeDomainEXT* {.size: sizeof(cint).} = enum | |
| 2831 VK_TIME_DOMAIN_DEVICE_EXT = 0 | |
| 2832 VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1 | |
| 2833 VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2 | |
| 2834 VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3 | |
| 2835 VkDebugReportFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 2836 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0b00000000000000000000000000000001 | |
| 2837 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0b00000000000000000000000000000010 | |
| 2838 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0b00000000000000000000000000000100 | |
| 2839 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0b00000000000000000000000000001000 | |
| 2840 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0b00000000000000000000000000010000 | |
| 2841 func toBits*(flags: openArray[VkDebugReportFlagBitsEXT]): VkDebugReportFlagsEXT = | |
| 2842 for flag in flags: | |
| 2843 result = VkDebugReportFlagsEXT(uint(result) or uint(flag)) | |
| 2844 func toEnums*(number: VkDebugReportFlagsEXT): seq[VkDebugReportFlagBitsEXT] = | |
| 2845 for value in VkDebugReportFlagBitsEXT.items: | |
| 2846 if (value.ord and cint(number)) > 0: | |
| 2847 result.add value | |
| 2848 proc `==`*(a, b: VkDebugReportFlagsEXT): bool = cint(a) == cint(b) | |
| 2849 type | |
| 2850 VkDebugReportObjectTypeEXT* {.size: sizeof(cint).} = enum | |
| 2851 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0 | |
| 2852 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1 | |
| 2853 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2 | |
| 2854 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3 | |
| 2855 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4 | |
| 2856 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5 | |
| 2857 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6 | |
| 2858 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7 | |
| 2859 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8 | |
| 2860 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9 | |
| 2861 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10 | |
| 2862 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11 | |
| 2863 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12 | |
| 2864 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13 | |
| 2865 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14 | |
| 2866 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15 | |
| 2867 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16 | |
| 2868 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17 | |
| 2869 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18 | |
| 2870 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19 | |
| 2871 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20 | |
| 2872 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21 | |
| 2873 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22 | |
| 2874 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23 | |
| 2875 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24 | |
| 2876 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25 | |
| 2877 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26 | |
| 2878 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27 | |
| 2879 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28 | |
| 2880 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29 | |
| 2881 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30 | |
| 2882 VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33 | |
| 2883 VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000 | |
| 2884 VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001 | |
| 2885 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000 | |
| 2886 VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000 | |
| 2887 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000 | |
| 2888 VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000 | |
| 2889 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000 | |
| 2890 VkDeviceMemoryReportEventTypeEXT* {.size: sizeof(cint).} = enum | |
| 2891 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0 | |
| 2892 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1 | |
| 2893 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2 | |
| 2894 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3 | |
| 2895 VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4 | |
| 2896 VkRasterizationOrderAMD* {.size: sizeof(cint).} = enum | |
| 2897 VK_RASTERIZATION_ORDER_STRICT_AMD = 0 | |
| 2898 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1 | |
| 2899 VkExternalMemoryHandleTypeFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 2900 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0b00000000000000000000000000000001 | |
| 2901 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0b00000000000000000000000000000010 | |
| 2902 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0b00000000000000000000000000000100 | |
| 2903 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0b00000000000000000000000000001000 | |
| 2904 func toBits*(flags: openArray[VkExternalMemoryHandleTypeFlagBitsNV]): VkExternalMemoryHandleTypeFlagsNV = | |
| 2905 for flag in flags: | |
| 2906 result = VkExternalMemoryHandleTypeFlagsNV(uint(result) or uint(flag)) | |
| 2907 func toEnums*(number: VkExternalMemoryHandleTypeFlagsNV): seq[VkExternalMemoryHandleTypeFlagBitsNV] = | |
| 2908 for value in VkExternalMemoryHandleTypeFlagBitsNV.items: | |
| 2909 if (value.ord and cint(number)) > 0: | |
| 2910 result.add value | |
| 2911 proc `==`*(a, b: VkExternalMemoryHandleTypeFlagsNV): bool = cint(a) == cint(b) | |
| 2912 type | |
| 2913 VkExternalMemoryFeatureFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 2914 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0b00000000000000000000000000000001 | |
| 2915 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0b00000000000000000000000000000010 | |
| 2916 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0b00000000000000000000000000000100 | |
| 2917 func toBits*(flags: openArray[VkExternalMemoryFeatureFlagBitsNV]): VkExternalMemoryFeatureFlagsNV = | |
| 2918 for flag in flags: | |
| 2919 result = VkExternalMemoryFeatureFlagsNV(uint(result) or uint(flag)) | |
| 2920 func toEnums*(number: VkExternalMemoryFeatureFlagsNV): seq[VkExternalMemoryFeatureFlagBitsNV] = | |
| 2921 for value in VkExternalMemoryFeatureFlagBitsNV.items: | |
| 2922 if (value.ord and cint(number)) > 0: | |
| 2923 result.add value | |
| 2924 proc `==`*(a, b: VkExternalMemoryFeatureFlagsNV): bool = cint(a) == cint(b) | |
| 2925 type | |
| 2926 VkValidationCheckEXT* {.size: sizeof(cint).} = enum | |
| 2927 VK_VALIDATION_CHECK_ALL_EXT = 0 | |
| 2928 VK_VALIDATION_CHECK_SHADERS_EXT = 1 | |
| 2929 VkValidationFeatureEnableEXT* {.size: sizeof(cint).} = enum | |
| 2930 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0 | |
| 2931 VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1 | |
| 2932 VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2 | |
| 2933 VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3 | |
| 2934 VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4 | |
| 2935 VkValidationFeatureDisableEXT* {.size: sizeof(cint).} = enum | |
| 2936 VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0 | |
| 2937 VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1 | |
| 2938 VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2 | |
| 2939 VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3 | |
| 2940 VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4 | |
| 2941 VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5 | |
| 2942 VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6 | |
| 2943 VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7 | |
| 2944 VkSubgroupFeatureFlagBits* {.size: sizeof(cint).} = enum | |
| 2945 VK_SUBGROUP_FEATURE_BASIC_BIT = 0b00000000000000000000000000000001 | |
| 2946 VK_SUBGROUP_FEATURE_VOTE_BIT = 0b00000000000000000000000000000010 | |
| 2947 VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0b00000000000000000000000000000100 | |
| 2948 VK_SUBGROUP_FEATURE_BALLOT_BIT = 0b00000000000000000000000000001000 | |
| 2949 VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0b00000000000000000000000000010000 | |
| 2950 VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0b00000000000000000000000000100000 | |
| 2951 VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0b00000000000000000000000001000000 | |
| 2952 VK_SUBGROUP_FEATURE_QUAD_BIT = 0b00000000000000000000000010000000 | |
| 2953 VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0b00000000000000000000000100000000 | |
| 2954 func toBits*(flags: openArray[VkSubgroupFeatureFlagBits]): VkSubgroupFeatureFlags = | |
| 2955 for flag in flags: | |
| 2956 result = VkSubgroupFeatureFlags(uint(result) or uint(flag)) | |
| 2957 func toEnums*(number: VkSubgroupFeatureFlags): seq[VkSubgroupFeatureFlagBits] = | |
| 2958 for value in VkSubgroupFeatureFlagBits.items: | |
| 2959 if (value.ord and cint(number)) > 0: | |
| 2960 result.add value | |
| 2961 proc `==`*(a, b: VkSubgroupFeatureFlags): bool = cint(a) == cint(b) | |
| 2962 type | |
| 2963 VkIndirectCommandsLayoutUsageFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 2964 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0b00000000000000000000000000000001 | |
| 2965 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0b00000000000000000000000000000010 | |
| 2966 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0b00000000000000000000000000000100 | |
| 2967 func toBits*(flags: openArray[VkIndirectCommandsLayoutUsageFlagBitsNV]): VkIndirectCommandsLayoutUsageFlagsNV = | |
| 2968 for flag in flags: | |
| 2969 result = VkIndirectCommandsLayoutUsageFlagsNV(uint(result) or uint(flag)) | |
| 2970 func toEnums*(number: VkIndirectCommandsLayoutUsageFlagsNV): seq[VkIndirectCommandsLayoutUsageFlagBitsNV] = | |
| 2971 for value in VkIndirectCommandsLayoutUsageFlagBitsNV.items: | |
| 2972 if (value.ord and cint(number)) > 0: | |
| 2973 result.add value | |
| 2974 proc `==`*(a, b: VkIndirectCommandsLayoutUsageFlagsNV): bool = cint(a) == cint(b) | |
| 2975 type | |
| 2976 VkIndirectStateFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 2977 VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0b00000000000000000000000000000001 | |
| 2978 func toBits*(flags: openArray[VkIndirectStateFlagBitsNV]): VkIndirectStateFlagsNV = | |
| 2979 for flag in flags: | |
| 2980 result = VkIndirectStateFlagsNV(uint(result) or uint(flag)) | |
| 2981 func toEnums*(number: VkIndirectStateFlagsNV): seq[VkIndirectStateFlagBitsNV] = | |
| 2982 for value in VkIndirectStateFlagBitsNV.items: | |
| 2983 if (value.ord and cint(number)) > 0: | |
| 2984 result.add value | |
| 2985 proc `==`*(a, b: VkIndirectStateFlagsNV): bool = cint(a) == cint(b) | |
| 2986 type | |
| 2987 VkIndirectCommandsTokenTypeNV* {.size: sizeof(cint).} = enum | |
| 2988 VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0 | |
| 2989 VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1 | |
| 2990 VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2 | |
| 2991 VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3 | |
| 2992 VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4 | |
| 2993 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5 | |
| 2994 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6 | |
| 2995 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7 | |
| 2996 VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000 | |
| 2997 VkPrivateDataSlotCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 2998 VK_PRIVATE_DATA_SLOT_CREATE_RESERVED_0_BIT_NV = 0b00000000000000000000000000000001 | |
| 2999 func toBits*(flags: openArray[VkPrivateDataSlotCreateFlagBits]): VkPrivateDataSlotCreateFlags = | |
| 3000 for flag in flags: | |
| 3001 result = VkPrivateDataSlotCreateFlags(uint(result) or uint(flag)) | |
| 3002 func toEnums*(number: VkPrivateDataSlotCreateFlags): seq[VkPrivateDataSlotCreateFlagBits] = | |
| 3003 for value in VkPrivateDataSlotCreateFlagBits.items: | |
| 3004 if (value.ord and cint(number)) > 0: | |
| 3005 result.add value | |
| 3006 proc `==`*(a, b: VkPrivateDataSlotCreateFlags): bool = cint(a) == cint(b) | |
| 3007 type | |
| 3008 VkDescriptorSetLayoutCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 3009 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3010 VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0b00000000000000000000000000000010 | |
| 3011 VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0b00000000000000000000000000000100 | |
| 3012 VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD = 0b00000000000000000000000000001000 | |
| 3013 VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0b00000000000000000000000000010000 | |
| 3014 VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0b00000000000000000000000000100000 | |
| 3015 func toBits*(flags: openArray[VkDescriptorSetLayoutCreateFlagBits]): VkDescriptorSetLayoutCreateFlags = | |
| 3016 for flag in flags: | |
| 3017 result = VkDescriptorSetLayoutCreateFlags(uint(result) or uint(flag)) | |
| 3018 func toEnums*(number: VkDescriptorSetLayoutCreateFlags): seq[VkDescriptorSetLayoutCreateFlagBits] = | |
| 3019 for value in VkDescriptorSetLayoutCreateFlagBits.items: | |
| 3020 if (value.ord and cint(number)) > 0: | |
| 3021 result.add value | |
| 3022 proc `==`*(a, b: VkDescriptorSetLayoutCreateFlags): bool = cint(a) == cint(b) | |
| 3023 type | |
| 3024 VkExternalMemoryHandleTypeFlagBits* {.size: sizeof(cint).} = enum | |
| 3025 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0b00000000000000000000000000000001 | |
| 3026 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0b00000000000000000000000000000010 | |
| 3027 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0b00000000000000000000000000000100 | |
| 3028 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0b00000000000000000000000000001000 | |
| 3029 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0b00000000000000000000000000010000 | |
| 3030 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0b00000000000000000000000000100000 | |
| 3031 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0b00000000000000000000000001000000 | |
| 3032 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0b00000000000000000000000010000000 | |
| 3033 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0b00000000000000000000000100000000 | |
| 3034 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0b00000000000000000000001000000000 | |
| 3035 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0b00000000000000000000010000000000 | |
| 3036 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0b00000000000000000000100000000000 | |
| 3037 VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0b00000000000000000001000000000000 | |
| 3038 VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV = 0b00000000000000000010000000000000 | |
| 3039 func toBits*(flags: openArray[VkExternalMemoryHandleTypeFlagBits]): VkExternalMemoryHandleTypeFlags = | |
| 3040 for flag in flags: | |
| 3041 result = VkExternalMemoryHandleTypeFlags(uint(result) or uint(flag)) | |
| 3042 func toEnums*(number: VkExternalMemoryHandleTypeFlags): seq[VkExternalMemoryHandleTypeFlagBits] = | |
| 3043 for value in VkExternalMemoryHandleTypeFlagBits.items: | |
| 3044 if (value.ord and cint(number)) > 0: | |
| 3045 result.add value | |
| 3046 proc `==`*(a, b: VkExternalMemoryHandleTypeFlags): bool = cint(a) == cint(b) | |
| 3047 type | |
| 3048 VkExternalMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum | |
| 3049 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0b00000000000000000000000000000001 | |
| 3050 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0b00000000000000000000000000000010 | |
| 3051 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0b00000000000000000000000000000100 | |
| 3052 func toBits*(flags: openArray[VkExternalMemoryFeatureFlagBits]): VkExternalMemoryFeatureFlags = | |
| 3053 for flag in flags: | |
| 3054 result = VkExternalMemoryFeatureFlags(uint(result) or uint(flag)) | |
| 3055 func toEnums*(number: VkExternalMemoryFeatureFlags): seq[VkExternalMemoryFeatureFlagBits] = | |
| 3056 for value in VkExternalMemoryFeatureFlagBits.items: | |
| 3057 if (value.ord and cint(number)) > 0: | |
| 3058 result.add value | |
| 3059 proc `==`*(a, b: VkExternalMemoryFeatureFlags): bool = cint(a) == cint(b) | |
| 3060 type | |
| 3061 VkExternalSemaphoreHandleTypeFlagBits* {.size: sizeof(cint).} = enum | |
| 3062 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0b00000000000000000000000000000001 | |
| 3063 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0b00000000000000000000000000000010 | |
| 3064 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0b00000000000000000000000000000100 | |
| 3065 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0b00000000000000000000000000001000 | |
| 3066 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0b00000000000000000000000000010000 | |
| 3067 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV = 0b00000000000000000000000000100000 | |
| 3068 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0b00000000000000000000000010000000 | |
| 3069 func toBits*(flags: openArray[VkExternalSemaphoreHandleTypeFlagBits]): VkExternalSemaphoreHandleTypeFlags = | |
| 3070 for flag in flags: | |
| 3071 result = VkExternalSemaphoreHandleTypeFlags(uint(result) or uint(flag)) | |
| 3072 func toEnums*(number: VkExternalSemaphoreHandleTypeFlags): seq[VkExternalSemaphoreHandleTypeFlagBits] = | |
| 3073 for value in VkExternalSemaphoreHandleTypeFlagBits.items: | |
| 3074 if (value.ord and cint(number)) > 0: | |
| 3075 result.add value | |
| 3076 proc `==`*(a, b: VkExternalSemaphoreHandleTypeFlags): bool = cint(a) == cint(b) | |
| 3077 type | |
| 3078 VkExternalSemaphoreFeatureFlagBits* {.size: sizeof(cint).} = enum | |
| 3079 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0b00000000000000000000000000000001 | |
| 3080 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0b00000000000000000000000000000010 | |
| 3081 func toBits*(flags: openArray[VkExternalSemaphoreFeatureFlagBits]): VkExternalSemaphoreFeatureFlags = | |
| 3082 for flag in flags: | |
| 3083 result = VkExternalSemaphoreFeatureFlags(uint(result) or uint(flag)) | |
| 3084 func toEnums*(number: VkExternalSemaphoreFeatureFlags): seq[VkExternalSemaphoreFeatureFlagBits] = | |
| 3085 for value in VkExternalSemaphoreFeatureFlagBits.items: | |
| 3086 if (value.ord and cint(number)) > 0: | |
| 3087 result.add value | |
| 3088 proc `==`*(a, b: VkExternalSemaphoreFeatureFlags): bool = cint(a) == cint(b) | |
| 3089 type | |
| 3090 VkSemaphoreImportFlagBits* {.size: sizeof(cint).} = enum | |
| 3091 VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0b00000000000000000000000000000001 | |
| 3092 func toBits*(flags: openArray[VkSemaphoreImportFlagBits]): VkSemaphoreImportFlags = | |
| 3093 for flag in flags: | |
| 3094 result = VkSemaphoreImportFlags(uint(result) or uint(flag)) | |
| 3095 func toEnums*(number: VkSemaphoreImportFlags): seq[VkSemaphoreImportFlagBits] = | |
| 3096 for value in VkSemaphoreImportFlagBits.items: | |
| 3097 if (value.ord and cint(number)) > 0: | |
| 3098 result.add value | |
| 3099 proc `==`*(a, b: VkSemaphoreImportFlags): bool = cint(a) == cint(b) | |
| 3100 type | |
| 3101 VkExternalFenceHandleTypeFlagBits* {.size: sizeof(cint).} = enum | |
| 3102 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0b00000000000000000000000000000001 | |
| 3103 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0b00000000000000000000000000000010 | |
| 3104 VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0b00000000000000000000000000000100 | |
| 3105 VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0b00000000000000000000000000001000 | |
| 3106 VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV = 0b00000000000000000000000000010000 | |
| 3107 VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV = 0b00000000000000000000000000100000 | |
| 3108 func toBits*(flags: openArray[VkExternalFenceHandleTypeFlagBits]): VkExternalFenceHandleTypeFlags = | |
| 3109 for flag in flags: | |
| 3110 result = VkExternalFenceHandleTypeFlags(uint(result) or uint(flag)) | |
| 3111 func toEnums*(number: VkExternalFenceHandleTypeFlags): seq[VkExternalFenceHandleTypeFlagBits] = | |
| 3112 for value in VkExternalFenceHandleTypeFlagBits.items: | |
| 3113 if (value.ord and cint(number)) > 0: | |
| 3114 result.add value | |
| 3115 proc `==`*(a, b: VkExternalFenceHandleTypeFlags): bool = cint(a) == cint(b) | |
| 3116 type | |
| 3117 VkExternalFenceFeatureFlagBits* {.size: sizeof(cint).} = enum | |
| 3118 VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0b00000000000000000000000000000001 | |
| 3119 VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0b00000000000000000000000000000010 | |
| 3120 func toBits*(flags: openArray[VkExternalFenceFeatureFlagBits]): VkExternalFenceFeatureFlags = | |
| 3121 for flag in flags: | |
| 3122 result = VkExternalFenceFeatureFlags(uint(result) or uint(flag)) | |
| 3123 func toEnums*(number: VkExternalFenceFeatureFlags): seq[VkExternalFenceFeatureFlagBits] = | |
| 3124 for value in VkExternalFenceFeatureFlagBits.items: | |
| 3125 if (value.ord and cint(number)) > 0: | |
| 3126 result.add value | |
| 3127 proc `==`*(a, b: VkExternalFenceFeatureFlags): bool = cint(a) == cint(b) | |
| 3128 type | |
| 3129 VkFenceImportFlagBits* {.size: sizeof(cint).} = enum | |
| 3130 VK_FENCE_IMPORT_TEMPORARY_BIT = 0b00000000000000000000000000000001 | |
| 3131 func toBits*(flags: openArray[VkFenceImportFlagBits]): VkFenceImportFlags = | |
| 3132 for flag in flags: | |
| 3133 result = VkFenceImportFlags(uint(result) or uint(flag)) | |
| 3134 func toEnums*(number: VkFenceImportFlags): seq[VkFenceImportFlagBits] = | |
| 3135 for value in VkFenceImportFlagBits.items: | |
| 3136 if (value.ord and cint(number)) > 0: | |
| 3137 result.add value | |
| 3138 proc `==`*(a, b: VkFenceImportFlags): bool = cint(a) == cint(b) | |
| 3139 type | |
| 3140 VkSurfaceCounterFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3141 VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3142 func toBits*(flags: openArray[VkSurfaceCounterFlagBitsEXT]): VkSurfaceCounterFlagsEXT = | |
| 3143 for flag in flags: | |
| 3144 result = VkSurfaceCounterFlagsEXT(uint(result) or uint(flag)) | |
| 3145 func toEnums*(number: VkSurfaceCounterFlagsEXT): seq[VkSurfaceCounterFlagBitsEXT] = | |
| 3146 for value in VkSurfaceCounterFlagBitsEXT.items: | |
| 3147 if (value.ord and cint(number)) > 0: | |
| 3148 result.add value | |
| 3149 proc `==`*(a, b: VkSurfaceCounterFlagsEXT): bool = cint(a) == cint(b) | |
| 3150 type | |
| 3151 VkDisplayPowerStateEXT* {.size: sizeof(cint).} = enum | |
| 3152 VK_DISPLAY_POWER_STATE_OFF_EXT = 0 | |
| 3153 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1 | |
| 3154 VK_DISPLAY_POWER_STATE_ON_EXT = 2 | |
| 3155 VkDeviceEventTypeEXT* {.size: sizeof(cint).} = enum | |
| 3156 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0 | |
| 3157 VkDisplayEventTypeEXT* {.size: sizeof(cint).} = enum | |
| 3158 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0 | |
| 3159 VkPeerMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum | |
| 3160 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0b00000000000000000000000000000001 | |
| 3161 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0b00000000000000000000000000000010 | |
| 3162 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0b00000000000000000000000000000100 | |
| 3163 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0b00000000000000000000000000001000 | |
| 3164 func toBits*(flags: openArray[VkPeerMemoryFeatureFlagBits]): VkPeerMemoryFeatureFlags = | |
| 3165 for flag in flags: | |
| 3166 result = VkPeerMemoryFeatureFlags(uint(result) or uint(flag)) | |
| 3167 func toEnums*(number: VkPeerMemoryFeatureFlags): seq[VkPeerMemoryFeatureFlagBits] = | |
| 3168 for value in VkPeerMemoryFeatureFlagBits.items: | |
| 3169 if (value.ord and cint(number)) > 0: | |
| 3170 result.add value | |
| 3171 proc `==`*(a, b: VkPeerMemoryFeatureFlags): bool = cint(a) == cint(b) | |
| 3172 type | |
| 3173 VkMemoryAllocateFlagBits* {.size: sizeof(cint).} = enum | |
| 3174 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0b00000000000000000000000000000001 | |
| 3175 VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0b00000000000000000000000000000010 | |
| 3176 VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0b00000000000000000000000000000100 | |
| 3177 func toBits*(flags: openArray[VkMemoryAllocateFlagBits]): VkMemoryAllocateFlags = | |
| 3178 for flag in flags: | |
| 3179 result = VkMemoryAllocateFlags(uint(result) or uint(flag)) | |
| 3180 func toEnums*(number: VkMemoryAllocateFlags): seq[VkMemoryAllocateFlagBits] = | |
| 3181 for value in VkMemoryAllocateFlagBits.items: | |
| 3182 if (value.ord and cint(number)) > 0: | |
| 3183 result.add value | |
| 3184 proc `==`*(a, b: VkMemoryAllocateFlags): bool = cint(a) == cint(b) | |
| 3185 type | |
| 3186 VkDeviceGroupPresentModeFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3187 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3188 VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3189 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0b00000000000000000000000000000100 | |
| 3190 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0b00000000000000000000000000001000 | |
| 3191 func toBits*(flags: openArray[VkDeviceGroupPresentModeFlagBitsKHR]): VkDeviceGroupPresentModeFlagsKHR = | |
| 3192 for flag in flags: | |
| 3193 result = VkDeviceGroupPresentModeFlagsKHR(uint(result) or uint(flag)) | |
| 3194 func toEnums*(number: VkDeviceGroupPresentModeFlagsKHR): seq[VkDeviceGroupPresentModeFlagBitsKHR] = | |
| 3195 for value in VkDeviceGroupPresentModeFlagBitsKHR.items: | |
| 3196 if (value.ord and cint(number)) > 0: | |
| 3197 result.add value | |
| 3198 proc `==`*(a, b: VkDeviceGroupPresentModeFlagsKHR): bool = cint(a) == cint(b) | |
| 3199 type | |
| 3200 VkSwapchainCreateFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3201 VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3202 VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3203 VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0b00000000000000000000000000000100 | |
| 3204 VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0b00000000000000000000000000001000 | |
| 3205 VK_SWAPCHAIN_CREATE_RESERVED_4_BIT_EXT = 0b00000000000000000000000000010000 | |
| 3206 func toBits*(flags: openArray[VkSwapchainCreateFlagBitsKHR]): VkSwapchainCreateFlagsKHR = | |
| 3207 for flag in flags: | |
| 3208 result = VkSwapchainCreateFlagsKHR(uint(result) or uint(flag)) | |
| 3209 func toEnums*(number: VkSwapchainCreateFlagsKHR): seq[VkSwapchainCreateFlagBitsKHR] = | |
| 3210 for value in VkSwapchainCreateFlagBitsKHR.items: | |
| 3211 if (value.ord and cint(number)) > 0: | |
| 3212 result.add value | |
| 3213 proc `==`*(a, b: VkSwapchainCreateFlagsKHR): bool = cint(a) == cint(b) | |
| 3214 type | |
| 3215 VkViewportCoordinateSwizzleNV* {.size: sizeof(cint).} = enum | |
| 3216 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0 | |
| 3217 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1 | |
| 3218 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2 | |
| 3219 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3 | |
| 3220 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4 | |
| 3221 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5 | |
| 3222 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6 | |
| 3223 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7 | |
| 3224 VkDiscardRectangleModeEXT* {.size: sizeof(cint).} = enum | |
| 3225 VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0 | |
| 3226 VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1 | |
| 3227 VkSubpassDescriptionFlagBits* {.size: sizeof(cint).} = enum | |
| 3228 VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0b00000000000000000000000000000001 | |
| 3229 VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0b00000000000000000000000000000010 | |
| 3230 VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0b00000000000000000000000000000100 | |
| 3231 VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0b00000000000000000000000000001000 | |
| 3232 VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0b00000000000000000000000000010000 | |
| 3233 VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0b00000000000000000000000000100000 | |
| 3234 VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0b00000000000000000000000001000000 | |
| 3235 VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0b00000000000000000000000010000000 | |
| 3236 func toBits*(flags: openArray[VkSubpassDescriptionFlagBits]): VkSubpassDescriptionFlags = | |
| 3237 for flag in flags: | |
| 3238 result = VkSubpassDescriptionFlags(uint(result) or uint(flag)) | |
| 3239 func toEnums*(number: VkSubpassDescriptionFlags): seq[VkSubpassDescriptionFlagBits] = | |
| 3240 for value in VkSubpassDescriptionFlagBits.items: | |
| 3241 if (value.ord and cint(number)) > 0: | |
| 3242 result.add value | |
| 3243 proc `==`*(a, b: VkSubpassDescriptionFlags): bool = cint(a) == cint(b) | |
| 3244 type | |
| 3245 VkPointClippingBehavior* {.size: sizeof(cint).} = enum | |
| 3246 VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0 | |
| 3247 VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1 | |
| 3248 VkSamplerReductionMode* {.size: sizeof(cint).} = enum | |
| 3249 VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0 | |
| 3250 VK_SAMPLER_REDUCTION_MODE_MIN = 1 | |
| 3251 VK_SAMPLER_REDUCTION_MODE_MAX = 2 | |
| 3252 VkTessellationDomainOrigin* {.size: sizeof(cint).} = enum | |
| 3253 VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0 | |
| 3254 VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1 | |
| 3255 VkSamplerYcbcrModelConversion* {.size: sizeof(cint).} = enum | |
| 3256 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0 | |
| 3257 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1 | |
| 3258 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2 | |
| 3259 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3 | |
| 3260 VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4 | |
| 3261 VkSamplerYcbcrRange* {.size: sizeof(cint).} = enum | |
| 3262 VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0 | |
| 3263 VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1 | |
| 3264 VkChromaLocation* {.size: sizeof(cint).} = enum | |
| 3265 VK_CHROMA_LOCATION_COSITED_EVEN = 0 | |
| 3266 VK_CHROMA_LOCATION_MIDPOINT = 1 | |
| 3267 VkBlendOverlapEXT* {.size: sizeof(cint).} = enum | |
| 3268 VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0 | |
| 3269 VK_BLEND_OVERLAP_DISJOINT_EXT = 1 | |
| 3270 VK_BLEND_OVERLAP_CONJOINT_EXT = 2 | |
| 3271 VkCoverageModulationModeNV* {.size: sizeof(cint).} = enum | |
| 3272 VK_COVERAGE_MODULATION_MODE_NONE_NV = 0 | |
| 3273 VK_COVERAGE_MODULATION_MODE_RGB_NV = 1 | |
| 3274 VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2 | |
| 3275 VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3 | |
| 3276 VkCoverageReductionModeNV* {.size: sizeof(cint).} = enum | |
| 3277 VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0 | |
| 3278 VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1 | |
| 3279 VkValidationCacheHeaderVersionEXT* {.size: sizeof(cint).} = enum | |
| 3280 VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1 | |
| 3281 VkShaderInfoTypeAMD* {.size: sizeof(cint).} = enum | |
| 3282 VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0 | |
| 3283 VK_SHADER_INFO_TYPE_BINARY_AMD = 1 | |
| 3284 VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2 | |
| 3285 VkQueueGlobalPriorityKHR* {.size: sizeof(cint).} = enum | |
| 3286 VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = 128 | |
| 3287 VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = 256 | |
| 3288 VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = 512 | |
| 3289 VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = 1024 | |
| 3290 VkDebugUtilsMessageSeverityFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3291 VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3292 VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0b00000000000000000000000000010000 | |
| 3293 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0b00000000000000000000000100000000 | |
| 3294 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0b00000000000000000001000000000000 | |
| 3295 func toBits*(flags: openArray[VkDebugUtilsMessageSeverityFlagBitsEXT]): VkDebugUtilsMessageSeverityFlagsEXT = | |
| 3296 for flag in flags: | |
| 3297 result = VkDebugUtilsMessageSeverityFlagsEXT(uint(result) or uint(flag)) | |
| 3298 func toEnums*(number: VkDebugUtilsMessageSeverityFlagsEXT): seq[VkDebugUtilsMessageSeverityFlagBitsEXT] = | |
| 3299 for value in VkDebugUtilsMessageSeverityFlagBitsEXT.items: | |
| 3300 if (value.ord and cint(number)) > 0: | |
| 3301 result.add value | |
| 3302 proc `==`*(a, b: VkDebugUtilsMessageSeverityFlagsEXT): bool = cint(a) == cint(b) | |
| 3303 type | |
| 3304 VkDebugUtilsMessageTypeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3305 VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3306 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0b00000000000000000000000000000010 | |
| 3307 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0b00000000000000000000000000000100 | |
| 3308 VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0b00000000000000000000000000001000 | |
| 3309 func toBits*(flags: openArray[VkDebugUtilsMessageTypeFlagBitsEXT]): VkDebugUtilsMessageTypeFlagsEXT = | |
| 3310 for flag in flags: | |
| 3311 result = VkDebugUtilsMessageTypeFlagsEXT(uint(result) or uint(flag)) | |
| 3312 func toEnums*(number: VkDebugUtilsMessageTypeFlagsEXT): seq[VkDebugUtilsMessageTypeFlagBitsEXT] = | |
| 3313 for value in VkDebugUtilsMessageTypeFlagBitsEXT.items: | |
| 3314 if (value.ord and cint(number)) > 0: | |
| 3315 result.add value | |
| 3316 proc `==`*(a, b: VkDebugUtilsMessageTypeFlagsEXT): bool = cint(a) == cint(b) | |
| 3317 type | |
| 3318 VkConservativeRasterizationModeEXT* {.size: sizeof(cint).} = enum | |
| 3319 VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0 | |
| 3320 VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1 | |
| 3321 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2 | |
| 3322 VkDescriptorBindingFlagBits* {.size: sizeof(cint).} = enum | |
| 3323 VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0b00000000000000000000000000000001 | |
| 3324 VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0b00000000000000000000000000000010 | |
| 3325 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0b00000000000000000000000000000100 | |
| 3326 VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0b00000000000000000000000000001000 | |
| 3327 VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM = 0b00000000000000000000000000010000 | |
| 3328 func toBits*(flags: openArray[VkDescriptorBindingFlagBits]): VkDescriptorBindingFlags = | |
| 3329 for flag in flags: | |
| 3330 result = VkDescriptorBindingFlags(uint(result) or uint(flag)) | |
| 3331 func toEnums*(number: VkDescriptorBindingFlags): seq[VkDescriptorBindingFlagBits] = | |
| 3332 for value in VkDescriptorBindingFlagBits.items: | |
| 3333 if (value.ord and cint(number)) > 0: | |
| 3334 result.add value | |
| 3335 proc `==`*(a, b: VkDescriptorBindingFlags): bool = cint(a) == cint(b) | |
| 3336 type | |
| 3337 VkVendorId* {.size: sizeof(cint).} = enum | |
| 3338 VK_VENDOR_ID_VIV = 65537 | |
| 3339 VK_VENDOR_ID_VSI = 65538 | |
| 3340 VK_VENDOR_ID_KAZAN = 65539 | |
| 3341 VK_VENDOR_ID_CODEPLAY = 65540 | |
| 3342 VK_VENDOR_ID_MESA = 65541 | |
| 3343 VK_VENDOR_ID_POCL = 65542 | |
| 3344 VkDriverId* {.size: sizeof(cint).} = enum | |
| 3345 VK_DRIVER_ID_AMD_PROPRIETARY = 1 | |
| 3346 VK_DRIVER_ID_AMD_OPEN_SOURCE = 2 | |
| 3347 VK_DRIVER_ID_MESA_RADV = 3 | |
| 3348 VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4 | |
| 3349 VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5 | |
| 3350 VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6 | |
| 3351 VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7 | |
| 3352 VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8 | |
| 3353 VK_DRIVER_ID_ARM_PROPRIETARY = 9 | |
| 3354 VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10 | |
| 3355 VK_DRIVER_ID_GGP_PROPRIETARY = 11 | |
| 3356 VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12 | |
| 3357 VK_DRIVER_ID_MESA_LLVMPIPE = 13 | |
| 3358 VK_DRIVER_ID_MOLTENVK = 14 | |
| 3359 VK_DRIVER_ID_COREAVI_PROPRIETARY = 15 | |
| 3360 VK_DRIVER_ID_JUICE_PROPRIETARY = 16 | |
| 3361 VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17 | |
| 3362 VK_DRIVER_ID_MESA_TURNIP = 18 | |
| 3363 VK_DRIVER_ID_MESA_V3DV = 19 | |
| 3364 VK_DRIVER_ID_MESA_PANVK = 20 | |
| 3365 VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21 | |
| 3366 VK_DRIVER_ID_MESA_VENUS = 22 | |
| 3367 VK_DRIVER_ID_MESA_DOZEN = 23 | |
| 3368 VK_DRIVER_ID_MESA_NVK = 24 | |
| 3369 VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25 | |
| 3370 VkConditionalRenderingFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3371 VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3372 func toBits*(flags: openArray[VkConditionalRenderingFlagBitsEXT]): VkConditionalRenderingFlagsEXT = | |
| 3373 for flag in flags: | |
| 3374 result = VkConditionalRenderingFlagsEXT(uint(result) or uint(flag)) | |
| 3375 func toEnums*(number: VkConditionalRenderingFlagsEXT): seq[VkConditionalRenderingFlagBitsEXT] = | |
| 3376 for value in VkConditionalRenderingFlagBitsEXT.items: | |
| 3377 if (value.ord and cint(number)) > 0: | |
| 3378 result.add value | |
| 3379 proc `==`*(a, b: VkConditionalRenderingFlagsEXT): bool = cint(a) == cint(b) | |
| 3380 type | |
| 3381 VkResolveModeFlagBits* {.size: sizeof(cint).} = enum | |
| 3382 VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0b00000000000000000000000000000001 | |
| 3383 VK_RESOLVE_MODE_AVERAGE_BIT = 0b00000000000000000000000000000010 | |
| 3384 VK_RESOLVE_MODE_MIN_BIT = 0b00000000000000000000000000000100 | |
| 3385 VK_RESOLVE_MODE_MAX_BIT = 0b00000000000000000000000000001000 | |
| 3386 func toBits*(flags: openArray[VkResolveModeFlagBits]): VkResolveModeFlags = | |
| 3387 for flag in flags: | |
| 3388 result = VkResolveModeFlags(uint(result) or uint(flag)) | |
| 3389 func toEnums*(number: VkResolveModeFlags): seq[VkResolveModeFlagBits] = | |
| 3390 for value in VkResolveModeFlagBits.items: | |
| 3391 if (value.ord and cint(number)) > 0: | |
| 3392 result.add value | |
| 3393 proc `==`*(a, b: VkResolveModeFlags): bool = cint(a) == cint(b) | |
| 3394 const | |
| 3395 VK_RESOLVE_MODE_NONE* = 0 | |
| 3396 type | |
| 3397 VkShadingRatePaletteEntryNV* {.size: sizeof(cint).} = enum | |
| 3398 VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0 | |
| 3399 VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1 | |
| 3400 VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2 | |
| 3401 VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3 | |
| 3402 VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4 | |
| 3403 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5 | |
| 3404 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6 | |
| 3405 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7 | |
| 3406 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8 | |
| 3407 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9 | |
| 3408 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10 | |
| 3409 VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11 | |
| 3410 VkCoarseSampleOrderTypeNV* {.size: sizeof(cint).} = enum | |
| 3411 VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0 | |
| 3412 VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1 | |
| 3413 VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2 | |
| 3414 VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3 | |
| 3415 VkGeometryInstanceFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3416 VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3417 VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3418 VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0b00000000000000000000000000000100 | |
| 3419 VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0b00000000000000000000000000001000 | |
| 3420 VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0b00000000000000000000000000010000 | |
| 3421 VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0b00000000000000000000000000100000 | |
| 3422 func toBits*(flags: openArray[VkGeometryInstanceFlagBitsKHR]): VkGeometryInstanceFlagsKHR = | |
| 3423 for flag in flags: | |
| 3424 result = VkGeometryInstanceFlagsKHR(uint(result) or uint(flag)) | |
| 3425 func toEnums*(number: VkGeometryInstanceFlagsKHR): seq[VkGeometryInstanceFlagBitsKHR] = | |
| 3426 for value in VkGeometryInstanceFlagBitsKHR.items: | |
| 3427 if (value.ord and cint(number)) > 0: | |
| 3428 result.add value | |
| 3429 proc `==`*(a, b: VkGeometryInstanceFlagsKHR): bool = cint(a) == cint(b) | |
| 3430 type | |
| 3431 VkGeometryFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3432 VK_GEOMETRY_OPAQUE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3433 VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3434 func toBits*(flags: openArray[VkGeometryFlagBitsKHR]): VkGeometryFlagsKHR = | |
| 3435 for flag in flags: | |
| 3436 result = VkGeometryFlagsKHR(uint(result) or uint(flag)) | |
| 3437 func toEnums*(number: VkGeometryFlagsKHR): seq[VkGeometryFlagBitsKHR] = | |
| 3438 for value in VkGeometryFlagBitsKHR.items: | |
| 3439 if (value.ord and cint(number)) > 0: | |
| 3440 result.add value | |
| 3441 proc `==`*(a, b: VkGeometryFlagsKHR): bool = cint(a) == cint(b) | |
| 3442 type | |
| 3443 VkBuildAccelerationStructureFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3444 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3445 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3446 VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0b00000000000000000000000000000100 | |
| 3447 VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0b00000000000000000000000000001000 | |
| 3448 VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0b00000000000000000000000000010000 | |
| 3449 VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0b00000000000000000000000000100000 | |
| 3450 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0b00000000000000000000000001000000 | |
| 3451 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0b00000000000000000000000010000000 | |
| 3452 VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0b00000000000000000000000100000000 | |
| 3453 VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_BIT_9_NV = 0b00000000000000000000001000000000 | |
| 3454 VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_BIT_10_NV = 0b00000000000000000000010000000000 | |
| 3455 func toBits*(flags: openArray[VkBuildAccelerationStructureFlagBitsKHR]): VkBuildAccelerationStructureFlagsKHR = | |
| 3456 for flag in flags: | |
| 3457 result = VkBuildAccelerationStructureFlagsKHR(uint(result) or uint(flag)) | |
| 3458 func toEnums*(number: VkBuildAccelerationStructureFlagsKHR): seq[VkBuildAccelerationStructureFlagBitsKHR] = | |
| 3459 for value in VkBuildAccelerationStructureFlagBitsKHR.items: | |
| 3460 if (value.ord and cint(number)) > 0: | |
| 3461 result.add value | |
| 3462 proc `==`*(a, b: VkBuildAccelerationStructureFlagsKHR): bool = cint(a) == cint(b) | |
| 3463 type | |
| 3464 VkAccelerationStructureCreateFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3465 VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3466 VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0b00000000000000000000000000000100 | |
| 3467 VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000001000 | |
| 3468 func toBits*(flags: openArray[VkAccelerationStructureCreateFlagBitsKHR]): VkAccelerationStructureCreateFlagsKHR = | |
| 3469 for flag in flags: | |
| 3470 result = VkAccelerationStructureCreateFlagsKHR(uint(result) or uint(flag)) | |
| 3471 func toEnums*(number: VkAccelerationStructureCreateFlagsKHR): seq[VkAccelerationStructureCreateFlagBitsKHR] = | |
| 3472 for value in VkAccelerationStructureCreateFlagBitsKHR.items: | |
| 3473 if (value.ord and cint(number)) > 0: | |
| 3474 result.add value | |
| 3475 proc `==`*(a, b: VkAccelerationStructureCreateFlagsKHR): bool = cint(a) == cint(b) | |
| 3476 type | |
| 3477 VkCopyAccelerationStructureModeKHR* {.size: sizeof(cint).} = enum | |
| 3478 VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0 | |
| 3479 VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1 | |
| 3480 VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2 | |
| 3481 VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3 | |
| 3482 VkBuildAccelerationStructureModeKHR* {.size: sizeof(cint).} = enum | |
| 3483 VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0 | |
| 3484 VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1 | |
| 3485 VkAccelerationStructureTypeKHR* {.size: sizeof(cint).} = enum | |
| 3486 VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0 | |
| 3487 VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1 | |
| 3488 VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2 | |
| 3489 VkGeometryTypeKHR* {.size: sizeof(cint).} = enum | |
| 3490 VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0 | |
| 3491 VK_GEOMETRY_TYPE_AABBS_KHR = 1 | |
| 3492 VK_GEOMETRY_TYPE_INSTANCES_KHR = 2 | |
| 3493 VkAccelerationStructureMemoryRequirementsTypeNV* {.size: sizeof(cint).} = enum | |
| 3494 VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0 | |
| 3495 VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1 | |
| 3496 VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2 | |
| 3497 VkAccelerationStructureBuildTypeKHR* {.size: sizeof(cint).} = enum | |
| 3498 VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0 | |
| 3499 VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1 | |
| 3500 VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2 | |
| 3501 VkRayTracingShaderGroupTypeKHR* {.size: sizeof(cint).} = enum | |
| 3502 VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0 | |
| 3503 VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1 | |
| 3504 VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2 | |
| 3505 VkAccelerationStructureCompatibilityKHR* {.size: sizeof(cint).} = enum | |
| 3506 VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0 | |
| 3507 VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1 | |
| 3508 VkShaderGroupShaderKHR* {.size: sizeof(cint).} = enum | |
| 3509 VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0 | |
| 3510 VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1 | |
| 3511 VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2 | |
| 3512 VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3 | |
| 3513 VkMemoryOverallocationBehaviorAMD* {.size: sizeof(cint).} = enum | |
| 3514 VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0 | |
| 3515 VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1 | |
| 3516 VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2 | |
| 3517 VkFramebufferCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 3518 VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0b00000000000000000000000000000001 | |
| 3519 func toBits*(flags: openArray[VkFramebufferCreateFlagBits]): VkFramebufferCreateFlags = | |
| 3520 for flag in flags: | |
| 3521 result = VkFramebufferCreateFlags(uint(result) or uint(flag)) | |
| 3522 func toEnums*(number: VkFramebufferCreateFlags): seq[VkFramebufferCreateFlagBits] = | |
| 3523 for value in VkFramebufferCreateFlagBits.items: | |
| 3524 if (value.ord and cint(number)) > 0: | |
| 3525 result.add value | |
| 3526 proc `==`*(a, b: VkFramebufferCreateFlags): bool = cint(a) == cint(b) | |
| 3527 type | |
| 3528 VkScopeNV* {.size: sizeof(cint).} = enum | |
| 3529 VK_SCOPE_DEVICE_NV = 1 | |
| 3530 VK_SCOPE_WORKGROUP_NV = 2 | |
| 3531 VK_SCOPE_SUBGROUP_NV = 3 | |
| 3532 VK_SCOPE_QUEUE_FAMILY_NV = 5 | |
| 3533 VkComponentTypeNV* {.size: sizeof(cint).} = enum | |
| 3534 VK_COMPONENT_TYPE_FLOAT16_NV = 0 | |
| 3535 VK_COMPONENT_TYPE_FLOAT32_NV = 1 | |
| 3536 VK_COMPONENT_TYPE_FLOAT64_NV = 2 | |
| 3537 VK_COMPONENT_TYPE_SINT8_NV = 3 | |
| 3538 VK_COMPONENT_TYPE_SINT16_NV = 4 | |
| 3539 VK_COMPONENT_TYPE_SINT32_NV = 5 | |
| 3540 VK_COMPONENT_TYPE_SINT64_NV = 6 | |
| 3541 VK_COMPONENT_TYPE_UINT8_NV = 7 | |
| 3542 VK_COMPONENT_TYPE_UINT16_NV = 8 | |
| 3543 VK_COMPONENT_TYPE_UINT32_NV = 9 | |
| 3544 VK_COMPONENT_TYPE_UINT64_NV = 10 | |
| 3545 VkDeviceDiagnosticsConfigFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 3546 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0b00000000000000000000000000000001 | |
| 3547 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0b00000000000000000000000000000010 | |
| 3548 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0b00000000000000000000000000000100 | |
| 3549 VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0b00000000000000000000000000001000 | |
| 3550 func toBits*(flags: openArray[VkDeviceDiagnosticsConfigFlagBitsNV]): VkDeviceDiagnosticsConfigFlagsNV = | |
| 3551 for flag in flags: | |
| 3552 result = VkDeviceDiagnosticsConfigFlagsNV(uint(result) or uint(flag)) | |
| 3553 func toEnums*(number: VkDeviceDiagnosticsConfigFlagsNV): seq[VkDeviceDiagnosticsConfigFlagBitsNV] = | |
| 3554 for value in VkDeviceDiagnosticsConfigFlagBitsNV.items: | |
| 3555 if (value.ord and cint(number)) > 0: | |
| 3556 result.add value | |
| 3557 proc `==`*(a, b: VkDeviceDiagnosticsConfigFlagsNV): bool = cint(a) == cint(b) | |
| 3558 type | |
| 3559 VkPipelineCreationFeedbackFlagBits* {.size: sizeof(cint).} = enum | |
| 3560 VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0b00000000000000000000000000000001 | |
| 3561 VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0b00000000000000000000000000000010 | |
| 3562 VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0b00000000000000000000000000000100 | |
| 3563 func toBits*(flags: openArray[VkPipelineCreationFeedbackFlagBits]): VkPipelineCreationFeedbackFlags = | |
| 3564 for flag in flags: | |
| 3565 result = VkPipelineCreationFeedbackFlags(uint(result) or uint(flag)) | |
| 3566 func toEnums*(number: VkPipelineCreationFeedbackFlags): seq[VkPipelineCreationFeedbackFlagBits] = | |
| 3567 for value in VkPipelineCreationFeedbackFlagBits.items: | |
| 3568 if (value.ord and cint(number)) > 0: | |
| 3569 result.add value | |
| 3570 proc `==`*(a, b: VkPipelineCreationFeedbackFlags): bool = cint(a) == cint(b) | |
| 3571 type | |
| 3572 VkFullScreenExclusiveEXT* {.size: sizeof(cint).} = enum | |
| 3573 VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0 | |
| 3574 VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1 | |
| 3575 VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2 | |
| 3576 VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3 | |
| 3577 VkPerformanceCounterScopeKHR* {.size: sizeof(cint).} = enum | |
| 3578 VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0 | |
| 3579 VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1 | |
| 3580 VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2 | |
| 3581 VkMemoryDecompressionMethodFlagBitsNV* {.size: 8.} = enum | |
| 3582 VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0b0000000000000000000000000000000000000000000000000000000000000001 | |
| 3583 func toBits*(flags: openArray[VkMemoryDecompressionMethodFlagBitsNV]): VkMemoryDecompressionMethodFlagsNV = | |
| 3584 for flag in flags: | |
| 3585 result = VkMemoryDecompressionMethodFlagsNV(uint64(result) or uint64(flag)) | |
| 3586 func toEnums*(number: VkMemoryDecompressionMethodFlagsNV): seq[VkMemoryDecompressionMethodFlagBitsNV] = | |
| 3587 for value in VkMemoryDecompressionMethodFlagBitsNV.items: | |
| 3588 if (cast[uint64](value) and uint64(number)) > 0: | |
| 3589 result.add value | |
| 3590 proc `==`*(a, b: VkMemoryDecompressionMethodFlagsNV): bool = uint64(a) == uint64(b) | |
| 3591 type | |
| 3592 VkPerformanceCounterUnitKHR* {.size: sizeof(cint).} = enum | |
| 3593 VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0 | |
| 3594 VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1 | |
| 3595 VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2 | |
| 3596 VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3 | |
| 3597 VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4 | |
| 3598 VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5 | |
| 3599 VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6 | |
| 3600 VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7 | |
| 3601 VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8 | |
| 3602 VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9 | |
| 3603 VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10 | |
| 3604 VkPerformanceCounterStorageKHR* {.size: sizeof(cint).} = enum | |
| 3605 VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0 | |
| 3606 VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1 | |
| 3607 VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2 | |
| 3608 VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3 | |
| 3609 VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4 | |
| 3610 VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5 | |
| 3611 VkPerformanceCounterDescriptionFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3612 VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3613 VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3614 func toBits*(flags: openArray[VkPerformanceCounterDescriptionFlagBitsKHR]): VkPerformanceCounterDescriptionFlagsKHR = | |
| 3615 for flag in flags: | |
| 3616 result = VkPerformanceCounterDescriptionFlagsKHR(uint(result) or uint(flag)) | |
| 3617 func toEnums*(number: VkPerformanceCounterDescriptionFlagsKHR): seq[VkPerformanceCounterDescriptionFlagBitsKHR] = | |
| 3618 for value in VkPerformanceCounterDescriptionFlagBitsKHR.items: | |
| 3619 if (value.ord and cint(number)) > 0: | |
| 3620 result.add value | |
| 3621 proc `==`*(a, b: VkPerformanceCounterDescriptionFlagsKHR): bool = cint(a) == cint(b) | |
| 3622 type | |
| 3623 VkPerformanceConfigurationTypeINTEL* {.size: sizeof(cint).} = enum | |
| 3624 VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0 | |
| 3625 VkQueryPoolSamplingModeINTEL* {.size: sizeof(cint).} = enum | |
| 3626 VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0 | |
| 3627 VkPerformanceOverrideTypeINTEL* {.size: sizeof(cint).} = enum | |
| 3628 VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0 | |
| 3629 VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1 | |
| 3630 VkPerformanceParameterTypeINTEL* {.size: sizeof(cint).} = enum | |
| 3631 VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0 | |
| 3632 VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1 | |
| 3633 VkPerformanceValueTypeINTEL* {.size: sizeof(cint).} = enum | |
| 3634 VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0 | |
| 3635 VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1 | |
| 3636 VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2 | |
| 3637 VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3 | |
| 3638 VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4 | |
| 3639 VkShaderFloatControlsIndependence* {.size: sizeof(cint).} = enum | |
| 3640 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0 | |
| 3641 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1 | |
| 3642 VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2 | |
| 3643 VkPipelineExecutableStatisticFormatKHR* {.size: sizeof(cint).} = enum | |
| 3644 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0 | |
| 3645 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1 | |
| 3646 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2 | |
| 3647 VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3 | |
| 3648 VkLineRasterizationModeEXT* {.size: sizeof(cint).} = enum | |
| 3649 VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0 | |
| 3650 VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1 | |
| 3651 VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2 | |
| 3652 VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3 | |
| 3653 VkFaultLevel* {.size: sizeof(cint).} = enum | |
| 3654 VK_FAULT_LEVEL_UNASSIGNED = 0 | |
| 3655 VK_FAULT_LEVEL_CRITICAL = 1 | |
| 3656 VK_FAULT_LEVEL_RECOVERABLE = 2 | |
| 3657 VK_FAULT_LEVEL_WARNING = 3 | |
| 3658 VkFaultType* {.size: sizeof(cint).} = enum | |
| 3659 VK_FAULT_TYPE_INVALID = 0 | |
| 3660 VK_FAULT_TYPE_UNASSIGNED = 1 | |
| 3661 VK_FAULT_TYPE_IMPLEMENTATION = 2 | |
| 3662 VK_FAULT_TYPE_SYSTEM = 3 | |
| 3663 VK_FAULT_TYPE_PHYSICAL_DEVICE = 4 | |
| 3664 VK_FAULT_TYPE_COMMAND_BUFFER_FULL = 5 | |
| 3665 VK_FAULT_TYPE_INVALID_API_USAGE = 6 | |
| 3666 VkFaultQueryBehavior* {.size: sizeof(cint).} = enum | |
| 3667 VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS = 0 | |
| 3668 VkToolPurposeFlagBits* {.size: sizeof(cint).} = enum | |
| 3669 VK_TOOL_PURPOSE_VALIDATION_BIT = 0b00000000000000000000000000000001 | |
| 3670 VK_TOOL_PURPOSE_PROFILING_BIT = 0b00000000000000000000000000000010 | |
| 3671 VK_TOOL_PURPOSE_TRACING_BIT = 0b00000000000000000000000000000100 | |
| 3672 VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0b00000000000000000000000000001000 | |
| 3673 VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0b00000000000000000000000000010000 | |
| 3674 VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0b00000000000000000000000000100000 | |
| 3675 VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0b00000000000000000000000001000000 | |
| 3676 func toBits*(flags: openArray[VkToolPurposeFlagBits]): VkToolPurposeFlags = | |
| 3677 for flag in flags: | |
| 3678 result = VkToolPurposeFlags(uint(result) or uint(flag)) | |
| 3679 func toEnums*(number: VkToolPurposeFlags): seq[VkToolPurposeFlagBits] = | |
| 3680 for value in VkToolPurposeFlagBits.items: | |
| 3681 if (value.ord and cint(number)) > 0: | |
| 3682 result.add value | |
| 3683 proc `==`*(a, b: VkToolPurposeFlags): bool = cint(a) == cint(b) | |
| 3684 type | |
| 3685 VkPipelineMatchControl* {.size: sizeof(cint).} = enum | |
| 3686 VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH = 0 | |
| 3687 VkFragmentShadingRateCombinerOpKHR* {.size: sizeof(cint).} = enum | |
| 3688 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0 | |
| 3689 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1 | |
| 3690 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2 | |
| 3691 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3 | |
| 3692 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4 | |
| 3693 VkFragmentShadingRateNV* {.size: sizeof(cint).} = enum | |
| 3694 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0 | |
| 3695 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1 | |
| 3696 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4 | |
| 3697 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5 | |
| 3698 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6 | |
| 3699 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9 | |
| 3700 VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10 | |
| 3701 VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11 | |
| 3702 VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12 | |
| 3703 VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13 | |
| 3704 VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14 | |
| 3705 VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15 | |
| 3706 VkFragmentShadingRateTypeNV* {.size: sizeof(cint).} = enum | |
| 3707 VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0 | |
| 3708 VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1 | |
| 3709 VkSubpassMergeStatusEXT* {.size: sizeof(cint).} = enum | |
| 3710 VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0 | |
| 3711 VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1 | |
| 3712 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2 | |
| 3713 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3 | |
| 3714 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4 | |
| 3715 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5 | |
| 3716 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6 | |
| 3717 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7 | |
| 3718 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8 | |
| 3719 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9 | |
| 3720 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10 | |
| 3721 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11 | |
| 3722 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12 | |
| 3723 VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13 | |
| 3724 VkAccessFlagBits2* {.size: 8.} = enum | |
| 3725 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000000001 | |
| 3726 VK_ACCESS_2_INDEX_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000000010 | |
| 3727 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000000100 | |
| 3728 VK_ACCESS_2_UNIFORM_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000001000 | |
| 3729 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000010000 | |
| 3730 VK_ACCESS_2_SHADER_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000000100000 | |
| 3731 VK_ACCESS_2_SHADER_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000000000001000000 | |
| 3732 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0b0000000000000000000000000000000000000000000000000000000010000000 | |
| 3733 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000000000100000000 | |
| 3734 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0b0000000000000000000000000000000000000000000000000000001000000000 | |
| 3735 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000000010000000000 | |
| 3736 VK_ACCESS_2_TRANSFER_READ_BIT = 0b0000000000000000000000000000000000000000000000000000100000000000 | |
| 3737 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000001000000000000 | |
| 3738 VK_ACCESS_2_HOST_READ_BIT = 0b0000000000000000000000000000000000000000000000000010000000000000 | |
| 3739 VK_ACCESS_2_HOST_WRITE_BIT = 0b0000000000000000000000000000000000000000000000000100000000000000 | |
| 3740 VK_ACCESS_2_MEMORY_READ_BIT = 0b0000000000000000000000000000000000000000000000001000000000000000 | |
| 3741 VK_ACCESS_2_MEMORY_WRITE_BIT = 0b0000000000000000000000000000000000000000000000010000000000000000 | |
| 3742 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0b0000000000000000000000000000000000000000000000100000000000000000 | |
| 3743 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0b0000000000000000000000000000000000000000000001000000000000000000 | |
| 3744 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0b0000000000000000000000000000000000000000000010000000000000000000 | |
| 3745 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0b0000000000000000000000000000000000000000000100000000000000000000 | |
| 3746 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0b0000000000000000000000000000000000000000001000000000000000000000 | |
| 3747 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0b0000000000000000000000000000000000000000010000000000000000000000 | |
| 3748 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0b0000000000000000000000000000000000000000100000000000000000000000 | |
| 3749 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0b0000000000000000000000000000000000000001000000000000000000000000 | |
| 3750 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0b0000000000000000000000000000000000000010000000000000000000000000 | |
| 3751 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0b0000000000000000000000000000000000000100000000000000000000000000 | |
| 3752 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0b0000000000000000000000000000000000001000000000000000000000000000 | |
| 3753 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0b0000000000000000000000000000000100000000000000000000000000000000 | |
| 3754 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0b0000000000000000000000000000001000000000000000000000000000000000 | |
| 3755 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0b0000000000000000000000000000010000000000000000000000000000000000 | |
| 3756 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0b0000000000000000000000000000100000000000000000000000000000000000 | |
| 3757 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0b0000000000000000000000000001000000000000000000000000000000000000 | |
| 3758 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0b0000000000000000000000000010000000000000000000000000000000000000 | |
| 3759 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0b0000000000000000000000000100000000000000000000000000000000000000 | |
| 3760 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0b0000000000000000000000001000000000000000000000000000000000000000 | |
| 3761 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0b0000000000000000000000010000000000000000000000000000000000000000 | |
| 3762 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0b0000000000000000000000100000000000000000000000000000000000000000 | |
| 3763 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0b0000000000000000000001000000000000000000000000000000000000000000 | |
| 3764 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0b0000000000000000000010000000000000000000000000000000000000000000 | |
| 3765 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0b0000000000000000000100000000000000000000000000000000000000000000 | |
| 3766 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0b0000000000000000001000000000000000000000000000000000000000000000 | |
| 3767 VK_ACCESS_2_RESERVED_46_BIT_EXT = 0b0000000000000000010000000000000000000000000000000000000000000000 | |
| 3768 func toBits*(flags: openArray[VkAccessFlagBits2]): VkAccessFlags2 = | |
| 3769 for flag in flags: | |
| 3770 result = VkAccessFlags2(uint64(result) or uint64(flag)) | |
| 3771 func toEnums*(number: VkAccessFlags2): seq[VkAccessFlagBits2] = | |
| 3772 for value in VkAccessFlagBits2.items: | |
| 3773 if (cast[uint64](value) and uint64(number)) > 0: | |
| 3774 result.add value | |
| 3775 proc `==`*(a, b: VkAccessFlags2): bool = uint64(a) == uint64(b) | |
| 3776 const | |
| 3777 VK_ACCESS_2_NONE* = 0 | |
| 3778 type | |
| 3779 VkPipelineStageFlagBits2* {.size: 8.} = enum | |
| 3780 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0b0000000000000000000000000000000000000000000000000000000000000001 | |
| 3781 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0b0000000000000000000000000000000000000000000000000000000000000010 | |
| 3782 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0b0000000000000000000000000000000000000000000000000000000000000100 | |
| 3783 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000000001000 | |
| 3784 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000000010000 | |
| 3785 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000000100000 | |
| 3786 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000001000000 | |
| 3787 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000000010000000 | |
| 3788 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0b0000000000000000000000000000000000000000000000000000000100000000 | |
| 3789 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0b0000000000000000000000000000000000000000000000000000001000000000 | |
| 3790 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0b0000000000000000000000000000000000000000000000000000010000000000 | |
| 3791 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0b0000000000000000000000000000000000000000000000000000100000000000 | |
| 3792 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0b0000000000000000000000000000000000000000000000000001000000000000 | |
| 3793 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0b0000000000000000000000000000000000000000000000000010000000000000 | |
| 3794 VK_PIPELINE_STAGE_2_HOST_BIT = 0b0000000000000000000000000000000000000000000000000100000000000000 | |
| 3795 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0b0000000000000000000000000000000000000000000000001000000000000000 | |
| 3796 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0b0000000000000000000000000000000000000000000000010000000000000000 | |
| 3797 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0b0000000000000000000000000000000000000000000000100000000000000000 | |
| 3798 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0b0000000000000000000000000000000000000000000001000000000000000000 | |
| 3799 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0b0000000000000000000000000000000000000000000010000000000000000000 | |
| 3800 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0b0000000000000000000000000000000000000000000100000000000000000000 | |
| 3801 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0b0000000000000000000000000000000000000000001000000000000000000000 | |
| 3802 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b0000000000000000000000000000000000000000010000000000000000000000 | |
| 3803 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0b0000000000000000000000000000000000000000100000000000000000000000 | |
| 3804 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0b0000000000000000000000000000000000000001000000000000000000000000 | |
| 3805 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0b0000000000000000000000000000000000000010000000000000000000000000 | |
| 3806 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0b0000000000000000000000000000000000000100000000000000000000000000 | |
| 3807 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0b0000000000000000000000000000000000001000000000000000000000000000 | |
| 3808 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0b0000000000000000000000000000000000010000000000000000000000000000 | |
| 3809 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0b0000000000000000000000000000000000100000000000000000000000000000 | |
| 3810 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0b0000000000000000000000000000000001000000000000000000000000000000 | |
| 3811 VK_PIPELINE_STAGE_2_COPY_BIT = 0b0000000000000000000000000000000100000000000000000000000000000000 | |
| 3812 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0b0000000000000000000000000000001000000000000000000000000000000000 | |
| 3813 VK_PIPELINE_STAGE_2_BLIT_BIT = 0b0000000000000000000000000000010000000000000000000000000000000000 | |
| 3814 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0b0000000000000000000000000000100000000000000000000000000000000000 | |
| 3815 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0b0000000000000000000000000001000000000000000000000000000000000000 | |
| 3816 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0b0000000000000000000000000010000000000000000000000000000000000000 | |
| 3817 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0b0000000000000000000000000100000000000000000000000000000000000000 | |
| 3818 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0b0000000000000000000000001000000000000000000000000000000000000000 | |
| 3819 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0b0000000000000000000000010000000000000000000000000000000000000000 | |
| 3820 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0b0000000000000000000000100000000000000000000000000000000000000000 | |
| 3821 func toBits*(flags: openArray[VkPipelineStageFlagBits2]): VkPipelineStageFlags2 = | |
| 3822 for flag in flags: | |
| 3823 result = VkPipelineStageFlags2(uint64(result) or uint64(flag)) | |
| 3824 func toEnums*(number: VkPipelineStageFlags2): seq[VkPipelineStageFlagBits2] = | |
| 3825 for value in VkPipelineStageFlagBits2.items: | |
| 3826 if (cast[uint64](value) and uint64(number)) > 0: | |
| 3827 result.add value | |
| 3828 proc `==`*(a, b: VkPipelineStageFlags2): bool = uint64(a) == uint64(b) | |
| 3829 const | |
| 3830 VK_PIPELINE_STAGE_2_NONE* = 0 | |
| 3831 type | |
| 3832 VkSubmitFlagBits* {.size: sizeof(cint).} = enum | |
| 3833 VK_SUBMIT_PROTECTED_BIT = 0b00000000000000000000000000000001 | |
| 3834 func toBits*(flags: openArray[VkSubmitFlagBits]): VkSubmitFlags = | |
| 3835 for flag in flags: | |
| 3836 result = VkSubmitFlags(uint(result) or uint(flag)) | |
| 3837 func toEnums*(number: VkSubmitFlags): seq[VkSubmitFlagBits] = | |
| 3838 for value in VkSubmitFlagBits.items: | |
| 3839 if (value.ord and cint(number)) > 0: | |
| 3840 result.add value | |
| 3841 proc `==`*(a, b: VkSubmitFlags): bool = cint(a) == cint(b) | |
| 3842 type | |
| 3843 VkEventCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 3844 VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0b00000000000000000000000000000001 | |
| 3845 func toBits*(flags: openArray[VkEventCreateFlagBits]): VkEventCreateFlags = | |
| 3846 for flag in flags: | |
| 3847 result = VkEventCreateFlags(uint(result) or uint(flag)) | |
| 3848 func toEnums*(number: VkEventCreateFlags): seq[VkEventCreateFlagBits] = | |
| 3849 for value in VkEventCreateFlagBits.items: | |
| 3850 if (value.ord and cint(number)) > 0: | |
| 3851 result.add value | |
| 3852 proc `==`*(a, b: VkEventCreateFlags): bool = cint(a) == cint(b) | |
| 3853 type | |
| 3854 VkPipelineLayoutCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 3855 VK_PIPELINE_LAYOUT_CREATE_RESERVED_0_BIT_AMD = 0b00000000000000000000000000000001 | |
| 3856 VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0b00000000000000000000000000000010 | |
| 3857 func toBits*(flags: openArray[VkPipelineLayoutCreateFlagBits]): VkPipelineLayoutCreateFlags = | |
| 3858 for flag in flags: | |
| 3859 result = VkPipelineLayoutCreateFlags(uint(result) or uint(flag)) | |
| 3860 func toEnums*(number: VkPipelineLayoutCreateFlags): seq[VkPipelineLayoutCreateFlagBits] = | |
| 3861 for value in VkPipelineLayoutCreateFlagBits.items: | |
| 3862 if (value.ord and cint(number)) > 0: | |
| 3863 result.add value | |
| 3864 proc `==`*(a, b: VkPipelineLayoutCreateFlags): bool = cint(a) == cint(b) | |
| 3865 type | |
| 3866 VkSciSyncClientTypeNV* {.size: sizeof(cint).} = enum | |
| 3867 VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_NV = 0 | |
| 3868 VK_SCI_SYNC_CLIENT_TYPE_WAITER_NV = 1 | |
| 3869 VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_WAITER_NV = 2 | |
| 3870 VkSciSyncPrimitiveTypeNV* {.size: sizeof(cint).} = enum | |
| 3871 VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV = 0 | |
| 3872 VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV = 1 | |
| 3873 VkProvokingVertexModeEXT* {.size: sizeof(cint).} = enum | |
| 3874 VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0 | |
| 3875 VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1 | |
| 3876 VkPipelineCacheValidationVersion* {.size: sizeof(cint).} = enum | |
| 3877 VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE = 1 | |
| 3878 VkAccelerationStructureMotionInstanceTypeNV* {.size: sizeof(cint).} = enum | |
| 3879 VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0 | |
| 3880 VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1 | |
| 3881 VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2 | |
| 3882 VkPipelineColorBlendStateCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 3883 VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3884 func toBits*(flags: openArray[VkPipelineColorBlendStateCreateFlagBits]): VkPipelineColorBlendStateCreateFlags = | |
| 3885 for flag in flags: | |
| 3886 result = VkPipelineColorBlendStateCreateFlags(uint(result) or uint(flag)) | |
| 3887 func toEnums*(number: VkPipelineColorBlendStateCreateFlags): seq[VkPipelineColorBlendStateCreateFlagBits] = | |
| 3888 for value in VkPipelineColorBlendStateCreateFlagBits.items: | |
| 3889 if (value.ord and cint(number)) > 0: | |
| 3890 result.add value | |
| 3891 proc `==`*(a, b: VkPipelineColorBlendStateCreateFlags): bool = cint(a) == cint(b) | |
| 3892 type | |
| 3893 VkPipelineDepthStencilStateCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 3894 VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3895 VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0b00000000000000000000000000000010 | |
| 3896 func toBits*(flags: openArray[VkPipelineDepthStencilStateCreateFlagBits]): VkPipelineDepthStencilStateCreateFlags = | |
| 3897 for flag in flags: | |
| 3898 result = VkPipelineDepthStencilStateCreateFlags(uint(result) or uint(flag)) | |
| 3899 func toEnums*(number: VkPipelineDepthStencilStateCreateFlags): seq[VkPipelineDepthStencilStateCreateFlagBits] = | |
| 3900 for value in VkPipelineDepthStencilStateCreateFlagBits.items: | |
| 3901 if (value.ord and cint(number)) > 0: | |
| 3902 result.add value | |
| 3903 proc `==`*(a, b: VkPipelineDepthStencilStateCreateFlags): bool = cint(a) == cint(b) | |
| 3904 type | |
| 3905 VkGraphicsPipelineLibraryFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3906 VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3907 VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0b00000000000000000000000000000010 | |
| 3908 VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0b00000000000000000000000000000100 | |
| 3909 VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0b00000000000000000000000000001000 | |
| 3910 func toBits*(flags: openArray[VkGraphicsPipelineLibraryFlagBitsEXT]): VkGraphicsPipelineLibraryFlagsEXT = | |
| 3911 for flag in flags: | |
| 3912 result = VkGraphicsPipelineLibraryFlagsEXT(uint(result) or uint(flag)) | |
| 3913 func toEnums*(number: VkGraphicsPipelineLibraryFlagsEXT): seq[VkGraphicsPipelineLibraryFlagBitsEXT] = | |
| 3914 for value in VkGraphicsPipelineLibraryFlagBitsEXT.items: | |
| 3915 if (value.ord and cint(number)) > 0: | |
| 3916 result.add value | |
| 3917 proc `==`*(a, b: VkGraphicsPipelineLibraryFlagsEXT): bool = cint(a) == cint(b) | |
| 3918 type | |
| 3919 VkDeviceAddressBindingFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3920 VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3921 func toBits*(flags: openArray[VkDeviceAddressBindingFlagBitsEXT]): VkDeviceAddressBindingFlagsEXT = | |
| 3922 for flag in flags: | |
| 3923 result = VkDeviceAddressBindingFlagsEXT(uint(result) or uint(flag)) | |
| 3924 func toEnums*(number: VkDeviceAddressBindingFlagsEXT): seq[VkDeviceAddressBindingFlagBitsEXT] = | |
| 3925 for value in VkDeviceAddressBindingFlagBitsEXT.items: | |
| 3926 if (value.ord and cint(number)) > 0: | |
| 3927 result.add value | |
| 3928 proc `==`*(a, b: VkDeviceAddressBindingFlagsEXT): bool = cint(a) == cint(b) | |
| 3929 type | |
| 3930 VkDeviceAddressBindingTypeEXT* {.size: sizeof(cint).} = enum | |
| 3931 VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0 | |
| 3932 VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1 | |
| 3933 VkPresentScalingFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3934 VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3935 VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0b00000000000000000000000000000010 | |
| 3936 VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0b00000000000000000000000000000100 | |
| 3937 func toBits*(flags: openArray[VkPresentScalingFlagBitsEXT]): VkPresentScalingFlagsEXT = | |
| 3938 for flag in flags: | |
| 3939 result = VkPresentScalingFlagsEXT(uint(result) or uint(flag)) | |
| 3940 func toEnums*(number: VkPresentScalingFlagsEXT): seq[VkPresentScalingFlagBitsEXT] = | |
| 3941 for value in VkPresentScalingFlagBitsEXT.items: | |
| 3942 if (value.ord and cint(number)) > 0: | |
| 3943 result.add value | |
| 3944 proc `==`*(a, b: VkPresentScalingFlagsEXT): bool = cint(a) == cint(b) | |
| 3945 type | |
| 3946 VkPresentGravityFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 3947 VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0b00000000000000000000000000000001 | |
| 3948 VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0b00000000000000000000000000000010 | |
| 3949 VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0b00000000000000000000000000000100 | |
| 3950 func toBits*(flags: openArray[VkPresentGravityFlagBitsEXT]): VkPresentGravityFlagsEXT = | |
| 3951 for flag in flags: | |
| 3952 result = VkPresentGravityFlagsEXT(uint(result) or uint(flag)) | |
| 3953 func toEnums*(number: VkPresentGravityFlagsEXT): seq[VkPresentGravityFlagBitsEXT] = | |
| 3954 for value in VkPresentGravityFlagBitsEXT.items: | |
| 3955 if (value.ord and cint(number)) > 0: | |
| 3956 result.add value | |
| 3957 proc `==`*(a, b: VkPresentGravityFlagsEXT): bool = cint(a) == cint(b) | |
| 3958 type | |
| 3959 VkVideoCodecOperationFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3960 VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3961 VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3962 VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0b00000000000000010000000000000000 | |
| 3963 VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0b00000000000000100000000000000000 | |
| 3964 func toBits*(flags: openArray[VkVideoCodecOperationFlagBitsKHR]): VkVideoCodecOperationFlagsKHR = | |
| 3965 for flag in flags: | |
| 3966 result = VkVideoCodecOperationFlagsKHR(uint(result) or uint(flag)) | |
| 3967 func toEnums*(number: VkVideoCodecOperationFlagsKHR): seq[VkVideoCodecOperationFlagBitsKHR] = | |
| 3968 for value in VkVideoCodecOperationFlagBitsKHR.items: | |
| 3969 if (value.ord and cint(number)) > 0: | |
| 3970 result.add value | |
| 3971 proc `==`*(a, b: VkVideoCodecOperationFlagsKHR): bool = cint(a) == cint(b) | |
| 3972 const | |
| 3973 VK_VIDEO_CODEC_OPERATION_NONE_KHR* = 0 | |
| 3974 type | |
| 3975 VkVideoChromaSubsamplingFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3976 VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3977 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0b00000000000000000000000000000010 | |
| 3978 VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0b00000000000000000000000000000100 | |
| 3979 VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0b00000000000000000000000000001000 | |
| 3980 func toBits*(flags: openArray[VkVideoChromaSubsamplingFlagBitsKHR]): VkVideoChromaSubsamplingFlagsKHR = | |
| 3981 for flag in flags: | |
| 3982 result = VkVideoChromaSubsamplingFlagsKHR(uint(result) or uint(flag)) | |
| 3983 func toEnums*(number: VkVideoChromaSubsamplingFlagsKHR): seq[VkVideoChromaSubsamplingFlagBitsKHR] = | |
| 3984 for value in VkVideoChromaSubsamplingFlagBitsKHR.items: | |
| 3985 if (value.ord and cint(number)) > 0: | |
| 3986 result.add value | |
| 3987 proc `==`*(a, b: VkVideoChromaSubsamplingFlagsKHR): bool = cint(a) == cint(b) | |
| 3988 const | |
| 3989 VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR* = 0 | |
| 3990 type | |
| 3991 VkVideoComponentBitDepthFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 3992 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0b00000000000000000000000000000001 | |
| 3993 VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0b00000000000000000000000000000100 | |
| 3994 VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0b00000000000000000000000000010000 | |
| 3995 func toBits*(flags: openArray[VkVideoComponentBitDepthFlagBitsKHR]): VkVideoComponentBitDepthFlagsKHR = | |
| 3996 for flag in flags: | |
| 3997 result = VkVideoComponentBitDepthFlagsKHR(uint(result) or uint(flag)) | |
| 3998 func toEnums*(number: VkVideoComponentBitDepthFlagsKHR): seq[VkVideoComponentBitDepthFlagBitsKHR] = | |
| 3999 for value in VkVideoComponentBitDepthFlagBitsKHR.items: | |
| 4000 if (value.ord and cint(number)) > 0: | |
| 4001 result.add value | |
| 4002 proc `==`*(a, b: VkVideoComponentBitDepthFlagsKHR): bool = cint(a) == cint(b) | |
| 4003 const | |
| 4004 VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR* = 0 | |
| 4005 type | |
| 4006 VkVideoCapabilityFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4007 VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4008 VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4009 func toBits*(flags: openArray[VkVideoCapabilityFlagBitsKHR]): VkVideoCapabilityFlagsKHR = | |
| 4010 for flag in flags: | |
| 4011 result = VkVideoCapabilityFlagsKHR(uint(result) or uint(flag)) | |
| 4012 func toEnums*(number: VkVideoCapabilityFlagsKHR): seq[VkVideoCapabilityFlagBitsKHR] = | |
| 4013 for value in VkVideoCapabilityFlagBitsKHR.items: | |
| 4014 if (value.ord and cint(number)) > 0: | |
| 4015 result.add value | |
| 4016 proc `==`*(a, b: VkVideoCapabilityFlagsKHR): bool = cint(a) == cint(b) | |
| 4017 type | |
| 4018 VkVideoSessionCreateFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4019 VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4020 func toBits*(flags: openArray[VkVideoSessionCreateFlagBitsKHR]): VkVideoSessionCreateFlagsKHR = | |
| 4021 for flag in flags: | |
| 4022 result = VkVideoSessionCreateFlagsKHR(uint(result) or uint(flag)) | |
| 4023 func toEnums*(number: VkVideoSessionCreateFlagsKHR): seq[VkVideoSessionCreateFlagBitsKHR] = | |
| 4024 for value in VkVideoSessionCreateFlagBitsKHR.items: | |
| 4025 if (value.ord and cint(number)) > 0: | |
| 4026 result.add value | |
| 4027 proc `==`*(a, b: VkVideoSessionCreateFlagsKHR): bool = cint(a) == cint(b) | |
| 4028 type | |
| 4029 VkVideoDecodeH264PictureLayoutFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4030 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4031 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4032 func toBits*(flags: openArray[VkVideoDecodeH264PictureLayoutFlagBitsKHR]): VkVideoDecodeH264PictureLayoutFlagsKHR = | |
| 4033 for flag in flags: | |
| 4034 result = VkVideoDecodeH264PictureLayoutFlagsKHR(uint(result) or uint(flag)) | |
| 4035 func toEnums*(number: VkVideoDecodeH264PictureLayoutFlagsKHR): seq[VkVideoDecodeH264PictureLayoutFlagBitsKHR] = | |
| 4036 for value in VkVideoDecodeH264PictureLayoutFlagBitsKHR.items: | |
| 4037 if (value.ord and cint(number)) > 0: | |
| 4038 result.add value | |
| 4039 proc `==`*(a, b: VkVideoDecodeH264PictureLayoutFlagsKHR): bool = cint(a) == cint(b) | |
| 4040 const | |
| 4041 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR* = 0 | |
| 4042 type | |
| 4043 VkVideoCodingControlFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4044 VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4045 VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4046 VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR = 0b00000000000000000000000000000100 | |
| 4047 func toBits*(flags: openArray[VkVideoCodingControlFlagBitsKHR]): VkVideoCodingControlFlagsKHR = | |
| 4048 for flag in flags: | |
| 4049 result = VkVideoCodingControlFlagsKHR(uint(result) or uint(flag)) | |
| 4050 func toEnums*(number: VkVideoCodingControlFlagsKHR): seq[VkVideoCodingControlFlagBitsKHR] = | |
| 4051 for value in VkVideoCodingControlFlagBitsKHR.items: | |
| 4052 if (value.ord and cint(number)) > 0: | |
| 4053 result.add value | |
| 4054 proc `==`*(a, b: VkVideoCodingControlFlagsKHR): bool = cint(a) == cint(b) | |
| 4055 type | |
| 4056 VkQueryResultStatusKHR* {.size: sizeof(cint).} = enum | |
| 4057 VK_QUERY_RESULT_STATUS_ERROR_KHR = -1 | |
| 4058 VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0 | |
| 4059 VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1 | |
| 4060 VkVideoDecodeUsageFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4061 VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4062 VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4063 VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0b00000000000000000000000000000100 | |
| 4064 func toBits*(flags: openArray[VkVideoDecodeUsageFlagBitsKHR]): VkVideoDecodeUsageFlagsKHR = | |
| 4065 for flag in flags: | |
| 4066 result = VkVideoDecodeUsageFlagsKHR(uint(result) or uint(flag)) | |
| 4067 func toEnums*(number: VkVideoDecodeUsageFlagsKHR): seq[VkVideoDecodeUsageFlagBitsKHR] = | |
| 4068 for value in VkVideoDecodeUsageFlagBitsKHR.items: | |
| 4069 if (value.ord and cint(number)) > 0: | |
| 4070 result.add value | |
| 4071 proc `==`*(a, b: VkVideoDecodeUsageFlagsKHR): bool = cint(a) == cint(b) | |
| 4072 const | |
| 4073 VK_VIDEO_DECODE_USAGE_DEFAULT_KHR* = 0 | |
| 4074 type | |
| 4075 VkVideoDecodeCapabilityFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4076 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4077 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4078 func toBits*(flags: openArray[VkVideoDecodeCapabilityFlagBitsKHR]): VkVideoDecodeCapabilityFlagsKHR = | |
| 4079 for flag in flags: | |
| 4080 result = VkVideoDecodeCapabilityFlagsKHR(uint(result) or uint(flag)) | |
| 4081 func toEnums*(number: VkVideoDecodeCapabilityFlagsKHR): seq[VkVideoDecodeCapabilityFlagBitsKHR] = | |
| 4082 for value in VkVideoDecodeCapabilityFlagBitsKHR.items: | |
| 4083 if (value.ord and cint(number)) > 0: | |
| 4084 result.add value | |
| 4085 proc `==`*(a, b: VkVideoDecodeCapabilityFlagsKHR): bool = cint(a) == cint(b) | |
| 4086 type | |
| 4087 VkVideoEncodeUsageFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4088 VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4089 VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4090 VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0b00000000000000000000000000000100 | |
| 4091 VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0b00000000000000000000000000001000 | |
| 4092 func toBits*(flags: openArray[VkVideoEncodeUsageFlagBitsKHR]): VkVideoEncodeUsageFlagsKHR = | |
| 4093 for flag in flags: | |
| 4094 result = VkVideoEncodeUsageFlagsKHR(uint(result) or uint(flag)) | |
| 4095 func toEnums*(number: VkVideoEncodeUsageFlagsKHR): seq[VkVideoEncodeUsageFlagBitsKHR] = | |
| 4096 for value in VkVideoEncodeUsageFlagBitsKHR.items: | |
| 4097 if (value.ord and cint(number)) > 0: | |
| 4098 result.add value | |
| 4099 proc `==`*(a, b: VkVideoEncodeUsageFlagsKHR): bool = cint(a) == cint(b) | |
| 4100 const | |
| 4101 VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR* = 0 | |
| 4102 type | |
| 4103 VkVideoEncodeContentFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4104 VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4105 VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4106 VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0b00000000000000000000000000000100 | |
| 4107 func toBits*(flags: openArray[VkVideoEncodeContentFlagBitsKHR]): VkVideoEncodeContentFlagsKHR = | |
| 4108 for flag in flags: | |
| 4109 result = VkVideoEncodeContentFlagsKHR(uint(result) or uint(flag)) | |
| 4110 func toEnums*(number: VkVideoEncodeContentFlagsKHR): seq[VkVideoEncodeContentFlagBitsKHR] = | |
| 4111 for value in VkVideoEncodeContentFlagBitsKHR.items: | |
| 4112 if (value.ord and cint(number)) > 0: | |
| 4113 result.add value | |
| 4114 proc `==`*(a, b: VkVideoEncodeContentFlagsKHR): bool = cint(a) == cint(b) | |
| 4115 const | |
| 4116 VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR* = 0 | |
| 4117 type | |
| 4118 VkVideoEncodeTuningModeKHR* {.size: sizeof(cint).} = enum | |
| 4119 VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0 | |
| 4120 VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1 | |
| 4121 VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2 | |
| 4122 VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3 | |
| 4123 VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4 | |
| 4124 VkVideoEncodeCapabilityFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4125 VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4126 func toBits*(flags: openArray[VkVideoEncodeCapabilityFlagBitsKHR]): VkVideoEncodeCapabilityFlagsKHR = | |
| 4127 for flag in flags: | |
| 4128 result = VkVideoEncodeCapabilityFlagsKHR(uint(result) or uint(flag)) | |
| 4129 func toEnums*(number: VkVideoEncodeCapabilityFlagsKHR): seq[VkVideoEncodeCapabilityFlagBitsKHR] = | |
| 4130 for value in VkVideoEncodeCapabilityFlagBitsKHR.items: | |
| 4131 if (value.ord and cint(number)) > 0: | |
| 4132 result.add value | |
| 4133 proc `==`*(a, b: VkVideoEncodeCapabilityFlagsKHR): bool = cint(a) == cint(b) | |
| 4134 type | |
| 4135 VkVideoEncodeRateControlModeFlagBitsKHR* {.size: sizeof(cint).} = enum | |
| 4136 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4137 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0b00000000000000000000000000000010 | |
| 4138 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0b00000000000000000000000000000100 | |
| 4139 func toBits*(flags: openArray[VkVideoEncodeRateControlModeFlagBitsKHR]): VkVideoEncodeRateControlModeFlagsKHR = | |
| 4140 for flag in flags: | |
| 4141 result = VkVideoEncodeRateControlModeFlagsKHR(uint(result) or uint(flag)) | |
| 4142 func toEnums*(number: VkVideoEncodeRateControlModeFlagsKHR): seq[VkVideoEncodeRateControlModeFlagBitsKHR] = | |
| 4143 for value in VkVideoEncodeRateControlModeFlagBitsKHR.items: | |
| 4144 if (value.ord and cint(number)) > 0: | |
| 4145 result.add value | |
| 4146 proc `==`*(a, b: VkVideoEncodeRateControlModeFlagsKHR): bool = cint(a) == cint(b) | |
| 4147 type | |
| 4148 VkVideoEncodeH264CapabilityFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4149 VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4150 VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4151 VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4152 VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0b00000000000000000000000000001000 | |
| 4153 VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0b00000000000000000000000000010000 | |
| 4154 VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0b00000000000000000000000000100000 | |
| 4155 VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0b00000000000000000000000001000000 | |
| 4156 VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0b00000000000000000000000010000000 | |
| 4157 VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0b00000000000000000000000100000000 | |
| 4158 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0b00000000000000000000001000000000 | |
| 4159 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0b00000000000000000000010000000000 | |
| 4160 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0b00000000000000000000100000000000 | |
| 4161 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0b00000000000000000001000000000000 | |
| 4162 VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0b00000000000000000010000000000000 | |
| 4163 VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0b00000000000000000100000000000000 | |
| 4164 VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0b00000000000000001000000000000000 | |
| 4165 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0b00000000000000010000000000000000 | |
| 4166 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0b00000000000000100000000000000000 | |
| 4167 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0b00000000000001000000000000000000 | |
| 4168 VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0b00000000000010000000000000000000 | |
| 4169 VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0b00000000000100000000000000000000 | |
| 4170 VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0b00000000001000000000000000000000 | |
| 4171 VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0b00000000010000000000000000000000 | |
| 4172 VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0b00000000100000000000000000000000 | |
| 4173 VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0b00000001000000000000000000000000 | |
| 4174 func toBits*(flags: openArray[VkVideoEncodeH264CapabilityFlagBitsEXT]): VkVideoEncodeH264CapabilityFlagsEXT = | |
| 4175 for flag in flags: | |
| 4176 result = VkVideoEncodeH264CapabilityFlagsEXT(uint(result) or uint(flag)) | |
| 4177 func toEnums*(number: VkVideoEncodeH264CapabilityFlagsEXT): seq[VkVideoEncodeH264CapabilityFlagBitsEXT] = | |
| 4178 for value in VkVideoEncodeH264CapabilityFlagBitsEXT.items: | |
| 4179 if (value.ord and cint(number)) > 0: | |
| 4180 result.add value | |
| 4181 proc `==`*(a, b: VkVideoEncodeH264CapabilityFlagsEXT): bool = cint(a) == cint(b) | |
| 4182 type | |
| 4183 VkVideoEncodeH264InputModeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4184 VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4185 VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4186 VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4187 func toBits*(flags: openArray[VkVideoEncodeH264InputModeFlagBitsEXT]): VkVideoEncodeH264InputModeFlagsEXT = | |
| 4188 for flag in flags: | |
| 4189 result = VkVideoEncodeH264InputModeFlagsEXT(uint(result) or uint(flag)) | |
| 4190 func toEnums*(number: VkVideoEncodeH264InputModeFlagsEXT): seq[VkVideoEncodeH264InputModeFlagBitsEXT] = | |
| 4191 for value in VkVideoEncodeH264InputModeFlagBitsEXT.items: | |
| 4192 if (value.ord and cint(number)) > 0: | |
| 4193 result.add value | |
| 4194 proc `==`*(a, b: VkVideoEncodeH264InputModeFlagsEXT): bool = cint(a) == cint(b) | |
| 4195 type | |
| 4196 VkVideoEncodeH264OutputModeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4197 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4198 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4199 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4200 func toBits*(flags: openArray[VkVideoEncodeH264OutputModeFlagBitsEXT]): VkVideoEncodeH264OutputModeFlagsEXT = | |
| 4201 for flag in flags: | |
| 4202 result = VkVideoEncodeH264OutputModeFlagsEXT(uint(result) or uint(flag)) | |
| 4203 func toEnums*(number: VkVideoEncodeH264OutputModeFlagsEXT): seq[VkVideoEncodeH264OutputModeFlagBitsEXT] = | |
| 4204 for value in VkVideoEncodeH264OutputModeFlagBitsEXT.items: | |
| 4205 if (value.ord and cint(number)) > 0: | |
| 4206 result.add value | |
| 4207 proc `==`*(a, b: VkVideoEncodeH264OutputModeFlagsEXT): bool = cint(a) == cint(b) | |
| 4208 type | |
| 4209 VkVideoEncodeH264RateControlStructureEXT* {.size: sizeof(cint).} = enum | |
| 4210 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0 | |
| 4211 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1 | |
| 4212 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2 | |
| 4213 VkImageConstraintsInfoFlagBitsFUCHSIA* {.size: sizeof(cint).} = enum | |
| 4214 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0b00000000000000000000000000000001 | |
| 4215 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0b00000000000000000000000000000010 | |
| 4216 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0b00000000000000000000000000000100 | |
| 4217 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0b00000000000000000000000000001000 | |
| 4218 VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0b00000000000000000000000000010000 | |
| 4219 func toBits*(flags: openArray[VkImageConstraintsInfoFlagBitsFUCHSIA]): VkImageConstraintsInfoFlagsFUCHSIA = | |
| 4220 for flag in flags: | |
| 4221 result = VkImageConstraintsInfoFlagsFUCHSIA(uint(result) or uint(flag)) | |
| 4222 func toEnums*(number: VkImageConstraintsInfoFlagsFUCHSIA): seq[VkImageConstraintsInfoFlagBitsFUCHSIA] = | |
| 4223 for value in VkImageConstraintsInfoFlagBitsFUCHSIA.items: | |
| 4224 if (value.ord and cint(number)) > 0: | |
| 4225 result.add value | |
| 4226 proc `==`*(a, b: VkImageConstraintsInfoFlagsFUCHSIA): bool = cint(a) == cint(b) | |
| 4227 type | |
| 4228 VkFormatFeatureFlagBits2* {.size: 8.} = enum | |
| 4229 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0b0000000000000000000000000000000000000000000000000000000000000001 | |
| 4230 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0b0000000000000000000000000000000000000000000000000000000000000010 | |
| 4231 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0b0000000000000000000000000000000000000000000000000000000000000100 | |
| 4232 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0b0000000000000000000000000000000000000000000000000000000000001000 | |
| 4233 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0b0000000000000000000000000000000000000000000000000000000000010000 | |
| 4234 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0b0000000000000000000000000000000000000000000000000000000000100000 | |
| 4235 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0b0000000000000000000000000000000000000000000000000000000001000000 | |
| 4236 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0b0000000000000000000000000000000000000000000000000000000010000000 | |
| 4237 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0b0000000000000000000000000000000000000000000000000000000100000000 | |
| 4238 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0b0000000000000000000000000000000000000000000000000000001000000000 | |
| 4239 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0b0000000000000000000000000000000000000000000000000000010000000000 | |
| 4240 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0b0000000000000000000000000000000000000000000000000000100000000000 | |
| 4241 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0b0000000000000000000000000000000000000000000000000001000000000000 | |
| 4242 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0b0000000000000000000000000000000000000000000000000010000000000000 | |
| 4243 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0b0000000000000000000000000000000000000000000000000100000000000000 | |
| 4244 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0b0000000000000000000000000000000000000000000000001000000000000000 | |
| 4245 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0b0000000000000000000000000000000000000000000000010000000000000000 | |
| 4246 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0b0000000000000000000000000000000000000000000000100000000000000000 | |
| 4247 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0b0000000000000000000000000000000000000000000001000000000000000000 | |
| 4248 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0b0000000000000000000000000000000000000000000010000000000000000000 | |
| 4249 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0b0000000000000000000000000000000000000000000100000000000000000000 | |
| 4250 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0b0000000000000000000000000000000000000000001000000000000000000000 | |
| 4251 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0b0000000000000000000000000000000000000000010000000000000000000000 | |
| 4252 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0b0000000000000000000000000000000000000000100000000000000000000000 | |
| 4253 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0b0000000000000000000000000000000000000001000000000000000000000000 | |
| 4254 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0b0000000000000000000000000000000000000010000000000000000000000000 | |
| 4255 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0b0000000000000000000000000000000000000100000000000000000000000000 | |
| 4256 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0b0000000000000000000000000000000000001000000000000000000000000000 | |
| 4257 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0b0000000000000000000000000000000000010000000000000000000000000000 | |
| 4258 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0b0000000000000000000000000000000000100000000000000000000000000000 | |
| 4259 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0b0000000000000000000000000000000001000000000000000000000000000000 | |
| 4260 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0b0000000000000000000000000000000010000000000000000000000000000000 | |
| 4261 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0b0000000000000000000000000000000100000000000000000000000000000000 | |
| 4262 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0b0000000000000000000000000000001000000000000000000000000000000000 | |
| 4263 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0b0000000000000000000000000000010000000000000000000000000000000000 | |
| 4264 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0b0000000000000000000000000000100000000000000000000000000000000000 | |
| 4265 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0b0000000000000000000000000001000000000000000000000000000000000000 | |
| 4266 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0b0000000000000000000000000010000000000000000000000000000000000000 | |
| 4267 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0b0000000000000000000000000100000000000000000000000000000000000000 | |
| 4268 VK_FORMAT_FEATURE_2_RESERVED_39_BIT_EXT = 0b0000000000000000000000001000000000000000000000000000000000000000 | |
| 4269 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0b0000000000000000000000010000000000000000000000000000000000000000 | |
| 4270 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0b0000000000000000000000100000000000000000000000000000000000000000 | |
| 4271 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0b0000000000000000000001000000000000000000000000000000000000000000 | |
| 4272 VK_FORMAT_FEATURE_2_RESERVED_44_BIT_EXT = 0b0000000000000000000100000000000000000000000000000000000000000000 | |
| 4273 VK_FORMAT_FEATURE_2_RESERVED_45_BIT_EXT = 0b0000000000000000001000000000000000000000000000000000000000000000 | |
| 4274 func toBits*(flags: openArray[VkFormatFeatureFlagBits2]): VkFormatFeatureFlags2 = | |
| 4275 for flag in flags: | |
| 4276 result = VkFormatFeatureFlags2(uint64(result) or uint64(flag)) | |
| 4277 func toEnums*(number: VkFormatFeatureFlags2): seq[VkFormatFeatureFlagBits2] = | |
| 4278 for value in VkFormatFeatureFlagBits2.items: | |
| 4279 if (cast[uint64](value) and uint64(number)) > 0: | |
| 4280 result.add value | |
| 4281 proc `==`*(a, b: VkFormatFeatureFlags2): bool = uint64(a) == uint64(b) | |
| 4282 type | |
| 4283 VkRenderingFlagBits* {.size: sizeof(cint).} = enum | |
| 4284 VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0b00000000000000000000000000000001 | |
| 4285 VK_RENDERING_SUSPENDING_BIT = 0b00000000000000000000000000000010 | |
| 4286 VK_RENDERING_RESUMING_BIT = 0b00000000000000000000000000000100 | |
| 4287 VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0b00000000000000000000000000001000 | |
| 4288 func toBits*(flags: openArray[VkRenderingFlagBits]): VkRenderingFlags = | |
| 4289 for flag in flags: | |
| 4290 result = VkRenderingFlags(uint(result) or uint(flag)) | |
| 4291 func toEnums*(number: VkRenderingFlags): seq[VkRenderingFlagBits] = | |
| 4292 for value in VkRenderingFlagBits.items: | |
| 4293 if (value.ord and cint(number)) > 0: | |
| 4294 result.add value | |
| 4295 proc `==`*(a, b: VkRenderingFlags): bool = cint(a) == cint(b) | |
| 4296 type | |
| 4297 VkVideoEncodeH265CapabilityFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4298 VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4299 VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4300 VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4301 VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0b00000000000000000000000000001000 | |
| 4302 VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0b00000000000000000000000000010000 | |
| 4303 VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0b00000000000000000000000000100000 | |
| 4304 VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0b00000000000000000000000001000000 | |
| 4305 VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0b00000000000000000000000010000000 | |
| 4306 VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0b00000000000000000000000100000000 | |
| 4307 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0b00000000000000000000001000000000 | |
| 4308 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0b00000000000000000000010000000000 | |
| 4309 VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0b00000000000000000000100000000000 | |
| 4310 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0b00000000000000000001000000000000 | |
| 4311 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0b00000000000000000010000000000000 | |
| 4312 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0b00000000000000000100000000000000 | |
| 4313 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0b00000000000000001000000000000000 | |
| 4314 VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0b00000000000000010000000000000000 | |
| 4315 VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0b00000000000000100000000000000000 | |
| 4316 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0b00000000000001000000000000000000 | |
| 4317 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0b00000000000010000000000000000000 | |
| 4318 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0b00000000000100000000000000000000 | |
| 4319 VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0b00000000001000000000000000000000 | |
| 4320 VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0b00000000010000000000000000000000 | |
| 4321 VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0b00000000100000000000000000000000 | |
| 4322 VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0b00000001000000000000000000000000 | |
| 4323 VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0b00000010000000000000000000000000 | |
| 4324 func toBits*(flags: openArray[VkVideoEncodeH265CapabilityFlagBitsEXT]): VkVideoEncodeH265CapabilityFlagsEXT = | |
| 4325 for flag in flags: | |
| 4326 result = VkVideoEncodeH265CapabilityFlagsEXT(uint(result) or uint(flag)) | |
| 4327 func toEnums*(number: VkVideoEncodeH265CapabilityFlagsEXT): seq[VkVideoEncodeH265CapabilityFlagBitsEXT] = | |
| 4328 for value in VkVideoEncodeH265CapabilityFlagBitsEXT.items: | |
| 4329 if (value.ord and cint(number)) > 0: | |
| 4330 result.add value | |
| 4331 proc `==`*(a, b: VkVideoEncodeH265CapabilityFlagsEXT): bool = cint(a) == cint(b) | |
| 4332 type | |
| 4333 VkVideoEncodeH265InputModeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4334 VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4335 VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4336 VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4337 func toBits*(flags: openArray[VkVideoEncodeH265InputModeFlagBitsEXT]): VkVideoEncodeH265InputModeFlagsEXT = | |
| 4338 for flag in flags: | |
| 4339 result = VkVideoEncodeH265InputModeFlagsEXT(uint(result) or uint(flag)) | |
| 4340 func toEnums*(number: VkVideoEncodeH265InputModeFlagsEXT): seq[VkVideoEncodeH265InputModeFlagBitsEXT] = | |
| 4341 for value in VkVideoEncodeH265InputModeFlagBitsEXT.items: | |
| 4342 if (value.ord and cint(number)) > 0: | |
| 4343 result.add value | |
| 4344 proc `==`*(a, b: VkVideoEncodeH265InputModeFlagsEXT): bool = cint(a) == cint(b) | |
| 4345 type | |
| 4346 VkVideoEncodeH265OutputModeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4347 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4348 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4349 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4350 func toBits*(flags: openArray[VkVideoEncodeH265OutputModeFlagBitsEXT]): VkVideoEncodeH265OutputModeFlagsEXT = | |
| 4351 for flag in flags: | |
| 4352 result = VkVideoEncodeH265OutputModeFlagsEXT(uint(result) or uint(flag)) | |
| 4353 func toEnums*(number: VkVideoEncodeH265OutputModeFlagsEXT): seq[VkVideoEncodeH265OutputModeFlagBitsEXT] = | |
| 4354 for value in VkVideoEncodeH265OutputModeFlagBitsEXT.items: | |
| 4355 if (value.ord and cint(number)) > 0: | |
| 4356 result.add value | |
| 4357 proc `==`*(a, b: VkVideoEncodeH265OutputModeFlagsEXT): bool = cint(a) == cint(b) | |
| 4358 type | |
| 4359 VkVideoEncodeH265RateControlStructureEXT* {.size: sizeof(cint).} = enum | |
| 4360 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0 | |
| 4361 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1 | |
| 4362 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2 | |
| 4363 VkVideoEncodeH265CtbSizeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4364 VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4365 VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4366 VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4367 func toBits*(flags: openArray[VkVideoEncodeH265CtbSizeFlagBitsEXT]): VkVideoEncodeH265CtbSizeFlagsEXT = | |
| 4368 for flag in flags: | |
| 4369 result = VkVideoEncodeH265CtbSizeFlagsEXT(uint(result) or uint(flag)) | |
| 4370 func toEnums*(number: VkVideoEncodeH265CtbSizeFlagsEXT): seq[VkVideoEncodeH265CtbSizeFlagBitsEXT] = | |
| 4371 for value in VkVideoEncodeH265CtbSizeFlagBitsEXT.items: | |
| 4372 if (value.ord and cint(number)) > 0: | |
| 4373 result.add value | |
| 4374 proc `==`*(a, b: VkVideoEncodeH265CtbSizeFlagsEXT): bool = cint(a) == cint(b) | |
| 4375 type | |
| 4376 VkVideoEncodeH265TransformBlockSizeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4377 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4378 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4379 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4380 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0b00000000000000000000000000001000 | |
| 4381 func toBits*(flags: openArray[VkVideoEncodeH265TransformBlockSizeFlagBitsEXT]): VkVideoEncodeH265TransformBlockSizeFlagsEXT = | |
| 4382 for flag in flags: | |
| 4383 result = VkVideoEncodeH265TransformBlockSizeFlagsEXT(uint(result) or uint(flag)) | |
| 4384 func toEnums*(number: VkVideoEncodeH265TransformBlockSizeFlagsEXT): seq[VkVideoEncodeH265TransformBlockSizeFlagBitsEXT] = | |
| 4385 for value in VkVideoEncodeH265TransformBlockSizeFlagBitsEXT.items: | |
| 4386 if (value.ord and cint(number)) > 0: | |
| 4387 result.add value | |
| 4388 proc `==`*(a, b: VkVideoEncodeH265TransformBlockSizeFlagsEXT): bool = cint(a) == cint(b) | |
| 4389 type | |
| 4390 VkExportMetalObjectTypeFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4391 VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4392 VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4393 VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4394 VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0b00000000000000000000000000001000 | |
| 4395 VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0b00000000000000000000000000010000 | |
| 4396 VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0b00000000000000000000000000100000 | |
| 4397 func toBits*(flags: openArray[VkExportMetalObjectTypeFlagBitsEXT]): VkExportMetalObjectTypeFlagsEXT = | |
| 4398 for flag in flags: | |
| 4399 result = VkExportMetalObjectTypeFlagsEXT(uint(result) or uint(flag)) | |
| 4400 func toEnums*(number: VkExportMetalObjectTypeFlagsEXT): seq[VkExportMetalObjectTypeFlagBitsEXT] = | |
| 4401 for value in VkExportMetalObjectTypeFlagBitsEXT.items: | |
| 4402 if (value.ord and cint(number)) > 0: | |
| 4403 result.add value | |
| 4404 proc `==`*(a, b: VkExportMetalObjectTypeFlagsEXT): bool = cint(a) == cint(b) | |
| 4405 type | |
| 4406 VkInstanceCreateFlagBits* {.size: sizeof(cint).} = enum | |
| 4407 VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0b00000000000000000000000000000001 | |
| 4408 func toBits*(flags: openArray[VkInstanceCreateFlagBits]): VkInstanceCreateFlags = | |
| 4409 for flag in flags: | |
| 4410 result = VkInstanceCreateFlags(uint(result) or uint(flag)) | |
| 4411 func toEnums*(number: VkInstanceCreateFlags): seq[VkInstanceCreateFlagBits] = | |
| 4412 for value in VkInstanceCreateFlagBits.items: | |
| 4413 if (value.ord and cint(number)) > 0: | |
| 4414 result.add value | |
| 4415 proc `==`*(a, b: VkInstanceCreateFlags): bool = cint(a) == cint(b) | |
| 4416 type | |
| 4417 VkImageCompressionFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4418 VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0b00000000000000000000000000000001 | |
| 4419 VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0b00000000000000000000000000000010 | |
| 4420 VK_IMAGE_COMPRESSION_DISABLED_EXT = 0b00000000000000000000000000000100 | |
| 4421 func toBits*(flags: openArray[VkImageCompressionFlagBitsEXT]): VkImageCompressionFlagsEXT = | |
| 4422 for flag in flags: | |
| 4423 result = VkImageCompressionFlagsEXT(uint(result) or uint(flag)) | |
| 4424 func toEnums*(number: VkImageCompressionFlagsEXT): seq[VkImageCompressionFlagBitsEXT] = | |
| 4425 for value in VkImageCompressionFlagBitsEXT.items: | |
| 4426 if (value.ord and cint(number)) > 0: | |
| 4427 result.add value | |
| 4428 proc `==`*(a, b: VkImageCompressionFlagsEXT): bool = cint(a) == cint(b) | |
| 4429 const | |
| 4430 VK_IMAGE_COMPRESSION_DEFAULT_EXT* = 0 | |
| 4431 type | |
| 4432 VkImageCompressionFixedRateFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4433 VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4434 VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4435 VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4436 VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0b00000000000000000000000000001000 | |
| 4437 VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0b00000000000000000000000000010000 | |
| 4438 VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0b00000000000000000000000000100000 | |
| 4439 VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0b00000000000000000000000001000000 | |
| 4440 VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0b00000000000000000000000010000000 | |
| 4441 VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0b00000000000000000000000100000000 | |
| 4442 VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0b00000000000000000000001000000000 | |
| 4443 VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0b00000000000000000000010000000000 | |
| 4444 VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0b00000000000000000000100000000000 | |
| 4445 VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0b00000000000000000001000000000000 | |
| 4446 VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0b00000000000000000010000000000000 | |
| 4447 VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0b00000000000000000100000000000000 | |
| 4448 VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0b00000000000000001000000000000000 | |
| 4449 VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0b00000000000000010000000000000000 | |
| 4450 VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0b00000000000000100000000000000000 | |
| 4451 VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0b00000000000001000000000000000000 | |
| 4452 VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0b00000000000010000000000000000000 | |
| 4453 VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0b00000000000100000000000000000000 | |
| 4454 VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0b00000000001000000000000000000000 | |
| 4455 VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0b00000000010000000000000000000000 | |
| 4456 VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0b00000000100000000000000000000000 | |
| 4457 func toBits*(flags: openArray[VkImageCompressionFixedRateFlagBitsEXT]): VkImageCompressionFixedRateFlagsEXT = | |
| 4458 for flag in flags: | |
| 4459 result = VkImageCompressionFixedRateFlagsEXT(uint(result) or uint(flag)) | |
| 4460 func toEnums*(number: VkImageCompressionFixedRateFlagsEXT): seq[VkImageCompressionFixedRateFlagBitsEXT] = | |
| 4461 for value in VkImageCompressionFixedRateFlagBitsEXT.items: | |
| 4462 if (value.ord and cint(number)) > 0: | |
| 4463 result.add value | |
| 4464 proc `==`*(a, b: VkImageCompressionFixedRateFlagsEXT): bool = cint(a) == cint(b) | |
| 4465 const | |
| 4466 VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT* = 0 | |
| 4467 type | |
| 4468 VkPipelineRobustnessBufferBehaviorEXT* {.size: sizeof(cint).} = enum | |
| 4469 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0 | |
| 4470 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1 | |
| 4471 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2 | |
| 4472 VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3 | |
| 4473 VkPipelineRobustnessImageBehaviorEXT* {.size: sizeof(cint).} = enum | |
| 4474 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0 | |
| 4475 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1 | |
| 4476 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2 | |
| 4477 VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3 | |
| 4478 VkOpticalFlowGridSizeFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 4479 VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0b00000000000000000000000000000001 | |
| 4480 VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0b00000000000000000000000000000010 | |
| 4481 VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0b00000000000000000000000000000100 | |
| 4482 VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0b00000000000000000000000000001000 | |
| 4483 func toBits*(flags: openArray[VkOpticalFlowGridSizeFlagBitsNV]): VkOpticalFlowGridSizeFlagsNV = | |
| 4484 for flag in flags: | |
| 4485 result = VkOpticalFlowGridSizeFlagsNV(uint(result) or uint(flag)) | |
| 4486 func toEnums*(number: VkOpticalFlowGridSizeFlagsNV): seq[VkOpticalFlowGridSizeFlagBitsNV] = | |
| 4487 for value in VkOpticalFlowGridSizeFlagBitsNV.items: | |
| 4488 if (value.ord and cint(number)) > 0: | |
| 4489 result.add value | |
| 4490 proc `==`*(a, b: VkOpticalFlowGridSizeFlagsNV): bool = cint(a) == cint(b) | |
| 4491 const | |
| 4492 VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV* = 0 | |
| 4493 type | |
| 4494 VkOpticalFlowUsageFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 4495 VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0b00000000000000000000000000000001 | |
| 4496 VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0b00000000000000000000000000000010 | |
| 4497 VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0b00000000000000000000000000000100 | |
| 4498 VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0b00000000000000000000000000001000 | |
| 4499 VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0b00000000000000000000000000010000 | |
| 4500 func toBits*(flags: openArray[VkOpticalFlowUsageFlagBitsNV]): VkOpticalFlowUsageFlagsNV = | |
| 4501 for flag in flags: | |
| 4502 result = VkOpticalFlowUsageFlagsNV(uint(result) or uint(flag)) | |
| 4503 func toEnums*(number: VkOpticalFlowUsageFlagsNV): seq[VkOpticalFlowUsageFlagBitsNV] = | |
| 4504 for value in VkOpticalFlowUsageFlagBitsNV.items: | |
| 4505 if (value.ord and cint(number)) > 0: | |
| 4506 result.add value | |
| 4507 proc `==`*(a, b: VkOpticalFlowUsageFlagsNV): bool = cint(a) == cint(b) | |
| 4508 const | |
| 4509 VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV* = 0 | |
| 4510 type | |
| 4511 VkOpticalFlowPerformanceLevelNV* {.size: sizeof(cint).} = enum | |
| 4512 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0 | |
| 4513 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1 | |
| 4514 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2 | |
| 4515 VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3 | |
| 4516 VkOpticalFlowSessionBindingPointNV* {.size: sizeof(cint).} = enum | |
| 4517 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0 | |
| 4518 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1 | |
| 4519 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2 | |
| 4520 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3 | |
| 4521 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4 | |
| 4522 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5 | |
| 4523 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6 | |
| 4524 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7 | |
| 4525 VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8 | |
| 4526 VkOpticalFlowSessionCreateFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 4527 VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0b00000000000000000000000000000001 | |
| 4528 VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0b00000000000000000000000000000010 | |
| 4529 VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0b00000000000000000000000000000100 | |
| 4530 VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0b00000000000000000000000000001000 | |
| 4531 VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0b00000000000000000000000000010000 | |
| 4532 func toBits*(flags: openArray[VkOpticalFlowSessionCreateFlagBitsNV]): VkOpticalFlowSessionCreateFlagsNV = | |
| 4533 for flag in flags: | |
| 4534 result = VkOpticalFlowSessionCreateFlagsNV(uint(result) or uint(flag)) | |
| 4535 func toEnums*(number: VkOpticalFlowSessionCreateFlagsNV): seq[VkOpticalFlowSessionCreateFlagBitsNV] = | |
| 4536 for value in VkOpticalFlowSessionCreateFlagBitsNV.items: | |
| 4537 if (value.ord and cint(number)) > 0: | |
| 4538 result.add value | |
| 4539 proc `==`*(a, b: VkOpticalFlowSessionCreateFlagsNV): bool = cint(a) == cint(b) | |
| 4540 type | |
| 4541 VkOpticalFlowExecuteFlagBitsNV* {.size: sizeof(cint).} = enum | |
| 4542 VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0b00000000000000000000000000000001 | |
| 4543 func toBits*(flags: openArray[VkOpticalFlowExecuteFlagBitsNV]): VkOpticalFlowExecuteFlagsNV = | |
| 4544 for flag in flags: | |
| 4545 result = VkOpticalFlowExecuteFlagsNV(uint(result) or uint(flag)) | |
| 4546 func toEnums*(number: VkOpticalFlowExecuteFlagsNV): seq[VkOpticalFlowExecuteFlagBitsNV] = | |
| 4547 for value in VkOpticalFlowExecuteFlagBitsNV.items: | |
| 4548 if (value.ord and cint(number)) > 0: | |
| 4549 result.add value | |
| 4550 proc `==`*(a, b: VkOpticalFlowExecuteFlagsNV): bool = cint(a) == cint(b) | |
| 4551 type | |
| 4552 VkMicromapTypeEXT* {.size: sizeof(cint).} = enum | |
| 4553 VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0 | |
| 4554 VkBuildMicromapFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4555 VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4556 VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0b00000000000000000000000000000010 | |
| 4557 VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0b00000000000000000000000000000100 | |
| 4558 func toBits*(flags: openArray[VkBuildMicromapFlagBitsEXT]): VkBuildMicromapFlagsEXT = | |
| 4559 for flag in flags: | |
| 4560 result = VkBuildMicromapFlagsEXT(uint(result) or uint(flag)) | |
| 4561 func toEnums*(number: VkBuildMicromapFlagsEXT): seq[VkBuildMicromapFlagBitsEXT] = | |
| 4562 for value in VkBuildMicromapFlagBitsEXT.items: | |
| 4563 if (value.ord and cint(number)) > 0: | |
| 4564 result.add value | |
| 4565 proc `==`*(a, b: VkBuildMicromapFlagsEXT): bool = cint(a) == cint(b) | |
| 4566 type | |
| 4567 VkMicromapCreateFlagBitsEXT* {.size: sizeof(cint).} = enum | |
| 4568 VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0b00000000000000000000000000000001 | |
| 4569 func toBits*(flags: openArray[VkMicromapCreateFlagBitsEXT]): VkMicromapCreateFlagsEXT = | |
| 4570 for flag in flags: | |
| 4571 result = VkMicromapCreateFlagsEXT(uint(result) or uint(flag)) | |
| 4572 func toEnums*(number: VkMicromapCreateFlagsEXT): seq[VkMicromapCreateFlagBitsEXT] = | |
| 4573 for value in VkMicromapCreateFlagBitsEXT.items: | |
| 4574 if (value.ord and cint(number)) > 0: | |
| 4575 result.add value | |
| 4576 proc `==`*(a, b: VkMicromapCreateFlagsEXT): bool = cint(a) == cint(b) | |
| 4577 type | |
| 4578 VkCopyMicromapModeEXT* {.size: sizeof(cint).} = enum | |
| 4579 VK_COPY_MICROMAP_MODE_CLONE_EXT = 0 | |
| 4580 VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1 | |
| 4581 VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2 | |
| 4582 VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3 | |
| 4583 VkBuildMicromapModeEXT* {.size: sizeof(cint).} = enum | |
| 4584 VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0 | |
| 4585 VkOpacityMicromapFormatEXT* {.size: sizeof(cint).} = enum | |
| 4586 VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1 | |
| 4587 VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2 | |
| 4588 VkOpacityMicromapSpecialIndexEXT* {.size: sizeof(cint).} = enum | |
| 4589 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4 | |
| 4590 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3 | |
| 4591 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2 | |
| 4592 VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1 | |
| 4593 VkDeviceFaultAddressTypeEXT* {.size: sizeof(cint).} = enum | |
| 4594 VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0 | |
| 4595 VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1 | |
| 4596 VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2 | |
| 4597 VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3 | |
| 4598 VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4 | |
| 4599 VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5 | |
| 4600 VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6 | |
| 4601 VkDeviceFaultVendorBinaryHeaderVersionEXT* {.size: sizeof(cint).} = enum | |
| 4602 VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT_ENUM = 1 | |
| 4603 proc `$`*(bitset: VkFramebufferCreateFlags): string = $toEnums(bitset) | |
| 4604 proc `$`*(bitset: VkRenderPassCreateFlags): string = $toEnums(bitset) | |
| 4605 proc `$`*(bitset: VkSamplerCreateFlags): string = $toEnums(bitset) | |
| 4606 proc `$`*(bitset: VkPipelineCacheCreateFlags): string = $toEnums(bitset) | |
| 4607 proc `$`*(bitset: VkPipelineShaderStageCreateFlags): string = $toEnums(bitset) | |
| 4608 proc `$`*(bitset: VkDescriptorSetLayoutCreateFlags): string = $toEnums(bitset) | |
| 4609 proc `$`*(bitset: VkInstanceCreateFlags): string = $toEnums(bitset) | |
| 4610 proc `$`*(bitset: VkDeviceQueueCreateFlags): string = $toEnums(bitset) | |
| 4611 proc `$`*(bitset: VkBufferCreateFlags): string = $toEnums(bitset) | |
| 4612 proc `$`*(bitset: VkBufferUsageFlags): string = $toEnums(bitset) | |
| 4613 proc `$`*(bitset: VkColorComponentFlags): string = $toEnums(bitset) | |
| 4614 proc `$`*(bitset: VkCommandPoolCreateFlags): string = $toEnums(bitset) | |
| 4615 proc `$`*(bitset: VkCommandPoolResetFlags): string = $toEnums(bitset) | |
| 4616 proc `$`*(bitset: VkCommandBufferResetFlags): string = $toEnums(bitset) | |
| 4617 proc `$`*(bitset: VkCommandBufferUsageFlags): string = $toEnums(bitset) | |
| 4618 proc `$`*(bitset: VkCullModeFlags): string = $toEnums(bitset) | |
| 4619 proc `$`*(bitset: VkFenceCreateFlags): string = $toEnums(bitset) | |
| 4620 proc `$`*(bitset: VkFormatFeatureFlags): string = $toEnums(bitset) | |
| 4621 proc `$`*(bitset: VkImageAspectFlags): string = $toEnums(bitset) | |
| 4622 proc `$`*(bitset: VkImageCreateFlags): string = $toEnums(bitset) | |
| 4623 proc `$`*(bitset: VkImageUsageFlags): string = $toEnums(bitset) | |
| 4624 proc `$`*(bitset: VkImageViewCreateFlags): string = $toEnums(bitset) | |
| 4625 proc `$`*(bitset: VkMemoryHeapFlags): string = $toEnums(bitset) | |
| 4626 proc `$`*(bitset: VkAccessFlags): string = $toEnums(bitset) | |
| 4627 proc `$`*(bitset: VkMemoryPropertyFlags): string = $toEnums(bitset) | |
| 4628 proc `$`*(bitset: VkPipelineCreateFlags): string = $toEnums(bitset) | |
| 4629 proc `$`*(bitset: VkQueryControlFlags): string = $toEnums(bitset) | |
| 4630 proc `$`*(bitset: VkQueryPipelineStatisticFlags): string = $toEnums(bitset) | |
| 4631 proc `$`*(bitset: VkQueryResultFlags): string = $toEnums(bitset) | |
| 4632 proc `$`*(bitset: VkQueueFlags): string = $toEnums(bitset) | |
| 4633 proc `$`*(bitset: VkShaderStageFlags): string = $toEnums(bitset) | |
| 4634 proc `$`*(bitset: VkSparseMemoryBindFlags): string = $toEnums(bitset) | |
| 4635 proc `$`*(bitset: VkStencilFaceFlags): string = $toEnums(bitset) | |
| 4636 proc `$`*(bitset: VkPipelineStageFlags): string = $toEnums(bitset) | |
| 4637 proc `$`*(bitset: VkSparseImageFormatFlags): string = $toEnums(bitset) | |
| 4638 proc `$`*(bitset: VkSampleCountFlags): string = $toEnums(bitset) | |
| 4639 proc `$`*(bitset: VkAttachmentDescriptionFlags): string = $toEnums(bitset) | |
| 4640 proc `$`*(bitset: VkDescriptorPoolCreateFlags): string = $toEnums(bitset) | |
| 4641 proc `$`*(bitset: VkDependencyFlags): string = $toEnums(bitset) | |
| 4642 proc `$`*(bitset: VkEventCreateFlags): string = $toEnums(bitset) | |
| 4643 proc `$`*(bitset: VkPipelineLayoutCreateFlags): string = $toEnums(bitset) | |
| 4644 proc `$`*(bitset: VkIndirectCommandsLayoutUsageFlagsNV): string = $toEnums(bitset) | |
| 4645 proc `$`*(bitset: VkIndirectStateFlagsNV): string = $toEnums(bitset) | |
| 4646 proc `$`*(bitset: VkPrivateDataSlotCreateFlags): string = $toEnums(bitset) | |
| 4647 proc `$`*(bitset: VkSubpassDescriptionFlags): string = $toEnums(bitset) | |
| 4648 proc `$`*(bitset: VkResolveModeFlags): string = $toEnums(bitset) | |
| 4649 proc `$`*(bitset: VkDescriptorBindingFlags): string = $toEnums(bitset) | |
| 4650 proc `$`*(bitset: VkConditionalRenderingFlagsEXT): string = $toEnums(bitset) | |
| 4651 proc `$`*(bitset: VkGeometryFlagsKHR): string = $toEnums(bitset) | |
| 4652 proc `$`*(bitset: VkGeometryInstanceFlagsKHR): string = $toEnums(bitset) | |
| 4653 proc `$`*(bitset: VkBuildAccelerationStructureFlagsKHR): string = $toEnums(bitset) | |
| 4654 proc `$`*(bitset: VkAccelerationStructureCreateFlagsKHR): string = $toEnums(bitset) | |
| 4655 proc `$`*(bitset: VkDeviceDiagnosticsConfigFlagsNV): string = $toEnums(bitset) | |
| 4656 proc `$`*(bitset: VkPipelineCreationFeedbackFlags): string = $toEnums(bitset) | |
| 4657 proc `$`*(bitset: VkPerformanceCounterDescriptionFlagsKHR): string = $toEnums(bitset) | |
| 4658 proc `$`*(bitset: VkSemaphoreWaitFlags): string = $toEnums(bitset) | |
| 4659 proc `$`*(bitset: VkToolPurposeFlags): string = $toEnums(bitset) | |
| 4660 proc `$`*(bitset: VkAccessFlags2): string = $toEnums(bitset) | |
| 4661 proc `$`*(bitset: VkPipelineStageFlags2): string = $toEnums(bitset) | |
| 4662 proc `$`*(bitset: VkImageConstraintsInfoFlagsFUCHSIA): string = $toEnums(bitset) | |
| 4663 proc `$`*(bitset: VkFormatFeatureFlags2): string = $toEnums(bitset) | |
| 4664 proc `$`*(bitset: VkRenderingFlags): string = $toEnums(bitset) | |
| 4665 proc `$`*(bitset: VkPipelineDepthStencilStateCreateFlags): string = $toEnums(bitset) | |
| 4666 proc `$`*(bitset: VkPipelineColorBlendStateCreateFlags): string = $toEnums(bitset) | |
| 4667 proc `$`*(bitset: VkImageCompressionFlagsEXT): string = $toEnums(bitset) | |
| 4668 proc `$`*(bitset: VkImageCompressionFixedRateFlagsEXT): string = $toEnums(bitset) | |
| 4669 proc `$`*(bitset: VkExportMetalObjectTypeFlagsEXT): string = $toEnums(bitset) | |
| 4670 proc `$`*(bitset: VkDeviceAddressBindingFlagsEXT): string = $toEnums(bitset) | |
| 4671 proc `$`*(bitset: VkBuildMicromapFlagsEXT): string = $toEnums(bitset) | |
| 4672 proc `$`*(bitset: VkMicromapCreateFlagsEXT): string = $toEnums(bitset) | |
| 4673 proc `$`*(bitset: VkMemoryDecompressionMethodFlagsNV): string = $toEnums(bitset) | |
| 4674 proc `$`*(bitset: VkCompositeAlphaFlagsKHR): string = $toEnums(bitset) | |
| 4675 proc `$`*(bitset: VkDisplayPlaneAlphaFlagsKHR): string = $toEnums(bitset) | |
| 4676 proc `$`*(bitset: VkSurfaceTransformFlagsKHR): string = $toEnums(bitset) | |
| 4677 proc `$`*(bitset: VkDebugReportFlagsEXT): string = $toEnums(bitset) | |
| 4678 proc `$`*(bitset: VkExternalMemoryHandleTypeFlagsNV): string = $toEnums(bitset) | |
| 4679 proc `$`*(bitset: VkExternalMemoryFeatureFlagsNV): string = $toEnums(bitset) | |
| 4680 proc `$`*(bitset: VkExternalMemoryHandleTypeFlags): string = $toEnums(bitset) | |
| 4681 proc `$`*(bitset: VkExternalMemoryFeatureFlags): string = $toEnums(bitset) | |
| 4682 proc `$`*(bitset: VkExternalSemaphoreHandleTypeFlags): string = $toEnums(bitset) | |
| 4683 proc `$`*(bitset: VkExternalSemaphoreFeatureFlags): string = $toEnums(bitset) | |
| 4684 proc `$`*(bitset: VkSemaphoreImportFlags): string = $toEnums(bitset) | |
| 4685 proc `$`*(bitset: VkExternalFenceHandleTypeFlags): string = $toEnums(bitset) | |
| 4686 proc `$`*(bitset: VkExternalFenceFeatureFlags): string = $toEnums(bitset) | |
| 4687 proc `$`*(bitset: VkFenceImportFlags): string = $toEnums(bitset) | |
| 4688 proc `$`*(bitset: VkSurfaceCounterFlagsEXT): string = $toEnums(bitset) | |
| 4689 proc `$`*(bitset: VkPeerMemoryFeatureFlags): string = $toEnums(bitset) | |
| 4690 proc `$`*(bitset: VkMemoryAllocateFlags): string = $toEnums(bitset) | |
| 4691 proc `$`*(bitset: VkDeviceGroupPresentModeFlagsKHR): string = $toEnums(bitset) | |
| 4692 proc `$`*(bitset: VkSwapchainCreateFlagsKHR): string = $toEnums(bitset) | |
| 4693 proc `$`*(bitset: VkSubgroupFeatureFlags): string = $toEnums(bitset) | |
| 4694 proc `$`*(bitset: VkDebugUtilsMessageSeverityFlagsEXT): string = $toEnums(bitset) | |
| 4695 proc `$`*(bitset: VkDebugUtilsMessageTypeFlagsEXT): string = $toEnums(bitset) | |
| 4696 proc `$`*(bitset: VkSwapchainImageUsageFlagsANDROID): string = $toEnums(bitset) | |
| 4697 proc `$`*(bitset: VkSubmitFlags): string = $toEnums(bitset) | |
| 4698 proc `$`*(bitset: VkGraphicsPipelineLibraryFlagsEXT): string = $toEnums(bitset) | |
| 4699 proc `$`*(bitset: VkOpticalFlowGridSizeFlagsNV): string = $toEnums(bitset) | |
| 4700 proc `$`*(bitset: VkOpticalFlowUsageFlagsNV): string = $toEnums(bitset) | |
| 4701 proc `$`*(bitset: VkOpticalFlowSessionCreateFlagsNV): string = $toEnums(bitset) | |
| 4702 proc `$`*(bitset: VkOpticalFlowExecuteFlagsNV): string = $toEnums(bitset) | |
| 4703 proc `$`*(bitset: VkPresentScalingFlagsEXT): string = $toEnums(bitset) | |
| 4704 proc `$`*(bitset: VkPresentGravityFlagsEXT): string = $toEnums(bitset) | |
| 4705 proc `$`*(bitset: VkVideoCodecOperationFlagsKHR): string = $toEnums(bitset) | |
| 4706 proc `$`*(bitset: VkVideoChromaSubsamplingFlagsKHR): string = $toEnums(bitset) | |
| 4707 proc `$`*(bitset: VkVideoComponentBitDepthFlagsKHR): string = $toEnums(bitset) | |
| 4708 proc `$`*(bitset: VkVideoCapabilityFlagsKHR): string = $toEnums(bitset) | |
| 4709 proc `$`*(bitset: VkVideoSessionCreateFlagsKHR): string = $toEnums(bitset) | |
| 4710 proc `$`*(bitset: VkVideoCodingControlFlagsKHR): string = $toEnums(bitset) | |
| 4711 proc `$`*(bitset: VkVideoDecodeUsageFlagsKHR): string = $toEnums(bitset) | |
| 4712 proc `$`*(bitset: VkVideoDecodeCapabilityFlagsKHR): string = $toEnums(bitset) | |
| 4713 proc `$`*(bitset: VkVideoDecodeH264PictureLayoutFlagsKHR): string = $toEnums(bitset) | |
| 4714 proc `$`*(bitset: VkVideoEncodeUsageFlagsKHR): string = $toEnums(bitset) | |
| 4715 proc `$`*(bitset: VkVideoEncodeContentFlagsKHR): string = $toEnums(bitset) | |
| 4716 proc `$`*(bitset: VkVideoEncodeCapabilityFlagsKHR): string = $toEnums(bitset) | |
| 4717 proc `$`*(bitset: VkVideoEncodeRateControlModeFlagsKHR): string = $toEnums(bitset) | |
| 4718 proc `$`*(bitset: VkVideoEncodeH264CapabilityFlagsEXT): string = $toEnums(bitset) | |
| 4719 proc `$`*(bitset: VkVideoEncodeH264InputModeFlagsEXT): string = $toEnums(bitset) | |
| 4720 proc `$`*(bitset: VkVideoEncodeH264OutputModeFlagsEXT): string = $toEnums(bitset) | |
| 4721 proc `$`*(bitset: VkVideoEncodeH265CapabilityFlagsEXT): string = $toEnums(bitset) | |
| 4722 proc `$`*(bitset: VkVideoEncodeH265InputModeFlagsEXT): string = $toEnums(bitset) | |
| 4723 proc `$`*(bitset: VkVideoEncodeH265OutputModeFlagsEXT): string = $toEnums(bitset) | |
| 4724 proc `$`*(bitset: VkVideoEncodeH265CtbSizeFlagsEXT): string = $toEnums(bitset) | |
| 4725 proc `$`*(bitset: VkVideoEncodeH265TransformBlockSizeFlagsEXT): string = $toEnums(bitset) | |
| 4726 type | |
| 4727 VkGeometryFlagsNV* = VkGeometryFlagsKHR | |
| 4728 VkGeometryInstanceFlagsNV* = VkGeometryInstanceFlagsKHR | |
| 4729 VkBuildAccelerationStructureFlagsNV* = VkBuildAccelerationStructureFlagsKHR | |
| 4730 VkPrivateDataSlotCreateFlagsEXT* = VkPrivateDataSlotCreateFlags | |
| 4731 VkDescriptorUpdateTemplateCreateFlagsKHR* = VkDescriptorUpdateTemplateCreateFlags | |
| 4732 VkPipelineCreationFeedbackFlagsEXT* = VkPipelineCreationFeedbackFlags | |
| 4733 VkSemaphoreWaitFlagsKHR* = VkSemaphoreWaitFlags | |
| 4734 VkAccessFlags2KHR* = VkAccessFlags2 | |
| 4735 VkPipelineStageFlags2KHR* = VkPipelineStageFlags2 | |
| 4736 VkFormatFeatureFlags2KHR* = VkFormatFeatureFlags2 | |
| 4737 VkRenderingFlagsKHR* = VkRenderingFlags | |
| 4738 VkPeerMemoryFeatureFlagsKHR* = VkPeerMemoryFeatureFlags | |
| 4739 VkMemoryAllocateFlagsKHR* = VkMemoryAllocateFlags | |
| 4740 VkCommandPoolTrimFlagsKHR* = VkCommandPoolTrimFlags | |
| 4741 VkExternalMemoryHandleTypeFlagsKHR* = VkExternalMemoryHandleTypeFlags | |
| 4742 VkExternalMemoryFeatureFlagsKHR* = VkExternalMemoryFeatureFlags | |
| 4743 VkExternalSemaphoreHandleTypeFlagsKHR* = VkExternalSemaphoreHandleTypeFlags | |
| 4744 VkExternalSemaphoreFeatureFlagsKHR* = VkExternalSemaphoreFeatureFlags | |
| 4745 VkSemaphoreImportFlagsKHR* = VkSemaphoreImportFlags | |
| 4746 VkExternalFenceHandleTypeFlagsKHR* = VkExternalFenceHandleTypeFlags | |
| 4747 VkExternalFenceFeatureFlagsKHR* = VkExternalFenceFeatureFlags | |
| 4748 VkFenceImportFlagsKHR* = VkFenceImportFlags | |
| 4749 VkDescriptorBindingFlagsEXT* = VkDescriptorBindingFlags | |
| 4750 VkResolveModeFlagsKHR* = VkResolveModeFlags | |
| 4751 VkToolPurposeFlagsEXT* = VkToolPurposeFlags | |
| 4752 VkSubmitFlagsKHR* = VkSubmitFlags | |
| 4753 VkPrivateDataSlotCreateFlagBitsEXT* = VkPrivateDataSlotCreateFlagBits | |
| 4754 VkDescriptorUpdateTemplateTypeKHR* = VkDescriptorUpdateTemplateType | |
| 4755 VkPointClippingBehaviorKHR* = VkPointClippingBehavior | |
| 4756 VkQueueGlobalPriorityEXT* = VkQueueGlobalPriorityKHR | |
| 4757 VkResolveModeFlagBitsKHR* = VkResolveModeFlagBits | |
| 4758 VkDescriptorBindingFlagBitsEXT* = VkDescriptorBindingFlagBits | |
| 4759 VkSemaphoreTypeKHR* = VkSemaphoreType | |
| 4760 VkGeometryFlagBitsNV* = VkGeometryFlagBitsKHR | |
| 4761 VkGeometryInstanceFlagBitsNV* = VkGeometryInstanceFlagBitsKHR | |
| 4762 VkBuildAccelerationStructureFlagBitsNV* = VkBuildAccelerationStructureFlagBitsKHR | |
| 4763 VkCopyAccelerationStructureModeNV* = VkCopyAccelerationStructureModeKHR | |
| 4764 VkAccelerationStructureTypeNV* = VkAccelerationStructureTypeKHR | |
| 4765 VkGeometryTypeNV* = VkGeometryTypeKHR | |
| 4766 VkRayTracingShaderGroupTypeNV* = VkRayTracingShaderGroupTypeKHR | |
| 4767 VkPipelineCreationFeedbackFlagBitsEXT* = VkPipelineCreationFeedbackFlagBits | |
| 4768 VkSemaphoreWaitFlagBitsKHR* = VkSemaphoreWaitFlagBits | |
| 4769 VkToolPurposeFlagBitsEXT* = VkToolPurposeFlagBits | |
| 4770 VkAccessFlagBits2KHR* = VkAccessFlagBits2 | |
| 4771 VkPipelineStageFlagBits2KHR* = VkPipelineStageFlagBits2 | |
| 4772 VkFormatFeatureFlagBits2KHR* = VkFormatFeatureFlagBits2 | |
| 4773 VkRenderingFlagBitsKHR* = VkRenderingFlagBits | |
| 4774 VkExternalMemoryHandleTypeFlagBitsKHR* = VkExternalMemoryHandleTypeFlagBits | |
| 4775 VkExternalMemoryFeatureFlagBitsKHR* = VkExternalMemoryFeatureFlagBits | |
| 4776 VkExternalSemaphoreHandleTypeFlagBitsKHR* = VkExternalSemaphoreHandleTypeFlagBits | |
| 4777 VkExternalSemaphoreFeatureFlagBitsKHR* = VkExternalSemaphoreFeatureFlagBits | |
| 4778 VkSemaphoreImportFlagBitsKHR* = VkSemaphoreImportFlagBits | |
| 4779 VkExternalFenceHandleTypeFlagBitsKHR* = VkExternalFenceHandleTypeFlagBits | |
| 4780 VkExternalFenceFeatureFlagBitsKHR* = VkExternalFenceFeatureFlagBits | |
| 4781 VkFenceImportFlagBitsKHR* = VkFenceImportFlagBits | |
| 4782 VkPeerMemoryFeatureFlagBitsKHR* = VkPeerMemoryFeatureFlagBits | |
| 4783 VkMemoryAllocateFlagBitsKHR* = VkMemoryAllocateFlagBits | |
| 4784 VkTessellationDomainOriginKHR* = VkTessellationDomainOrigin | |
| 4785 VkSamplerYcbcrModelConversionKHR* = VkSamplerYcbcrModelConversion | |
| 4786 VkSamplerYcbcrRangeKHR* = VkSamplerYcbcrRange | |
| 4787 VkChromaLocationKHR* = VkChromaLocation | |
| 4788 VkSamplerReductionModeEXT* = VkSamplerReductionMode | |
| 4789 VkShaderFloatControlsIndependenceKHR* = VkShaderFloatControlsIndependence | |
| 4790 VkSubmitFlagBitsKHR* = VkSubmitFlagBits | |
| 4791 VkDriverIdKHR* = VkDriverId | |
| 4792 type | |
| 4793 PFN_vkInternalAllocationNotification* = proc(pUserData: pointer, size: csize_t, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope): void {.cdecl.} | |
| 4794 PFN_vkInternalFreeNotification* = proc(pUserData: pointer, size: csize_t, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope): void {.cdecl.} | |
| 4795 PFN_vkReallocationFunction* = proc(pUserData: pointer, pOriginal: pointer, size: csize_t, alignment: csize_t, allocationScope: VkSystemAllocationScope): pointer {.cdecl.} | |
| 4796 PFN_vkAllocationFunction* = proc(pUserData: pointer, size: csize_t, alignment: csize_t, allocationScope: VkSystemAllocationScope): pointer {.cdecl.} | |
| 4797 PFN_vkFreeFunction* = proc(pUserData: pointer, pMemory: pointer): void {.cdecl.} | |
| 4798 PFN_vkVoidFunction* = proc(): void {.cdecl.} | |
| 4799 PFN_vkDebugReportCallbackEXT* = proc(flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, theobject: uint64, location: csize_t, messageCode: int32, pLayerPrefix: cstring, pMessage: cstring, pUserData: pointer): VkBool32 {.cdecl.} | |
| 4800 PFN_vkDebugUtilsMessengerCallbackEXT* = proc(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT, pUserData: pointer): VkBool32 {.cdecl.} | |
| 4801 PFN_vkFaultCallbackFunction* = proc(unrecordedFaults: VkBool32, faultCount: uint32, pFaults: ptr VkFaultData): void {.cdecl.} | |
| 4802 PFN_vkDeviceMemoryReportCallbackEXT* = proc(pCallbackData: ptr VkDeviceMemoryReportCallbackDataEXT, pUserData: pointer): void {.cdecl.} | |
| 4803 PFN_vkGetInstanceProcAddrLUNARG* = proc(instance: VkInstance, pName: cstring): PFN_vkVoidFunction {.cdecl.} | |
| 4804 VkBaseOutStructure* = object | |
| 4805 sType*: VkStructureType | |
| 4806 pNext*: ptr VkBaseOutStructure | |
| 4807 VkBaseInStructure* = object | |
| 4808 sType*: VkStructureType | |
| 4809 pNext*: ptr VkBaseInStructure | |
| 4810 VkOffset2D* = object | |
| 4811 x*: int32 | |
| 4812 y*: int32 | |
| 4813 VkOffset3D* = object | |
| 4814 x*: int32 | |
| 4815 y*: int32 | |
| 4816 z*: int32 | |
| 4817 VkExtent2D* = object | |
| 4818 width*: uint32 | |
| 4819 height*: uint32 | |
| 4820 VkExtent3D* = object | |
| 4821 width*: uint32 | |
| 4822 height*: uint32 | |
| 4823 depth*: uint32 | |
| 4824 VkViewport* = object | |
| 4825 x*: float32 | |
| 4826 y*: float32 | |
| 4827 width*: float32 | |
| 4828 height*: float32 | |
| 4829 minDepth*: float32 | |
| 4830 maxDepth*: float32 | |
| 4831 VkRect2D* = object | |
| 4832 offset*: VkOffset2D | |
| 4833 extent*: VkExtent2D | |
| 4834 VkClearRect* = object | |
| 4835 rect*: VkRect2D | |
| 4836 baseArrayLayer*: uint32 | |
| 4837 layerCount*: uint32 | |
| 4838 VkComponentMapping* = object | |
| 4839 r*: VkComponentSwizzle | |
| 4840 g*: VkComponentSwizzle | |
| 4841 b*: VkComponentSwizzle | |
| 4842 a*: VkComponentSwizzle | |
| 4843 VkPhysicalDeviceProperties* = object | |
| 4844 apiVersion*: uint32 | |
| 4845 driverVersion*: uint32 | |
| 4846 vendorID*: uint32 | |
| 4847 deviceID*: uint32 | |
| 4848 deviceType*: VkPhysicalDeviceType | |
| 4849 deviceName*: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char] | |
| 4850 pipelineCacheUUID*: array[VK_UUID_SIZE, uint8] | |
| 4851 limits*: VkPhysicalDeviceLimits | |
| 4852 sparseProperties*: VkPhysicalDeviceSparseProperties | |
| 4853 VkExtensionProperties* = object | |
| 4854 extensionName*: array[VK_MAX_EXTENSION_NAME_SIZE, char] | |
| 4855 specVersion*: uint32 | |
| 4856 VkLayerProperties* = object | |
| 4857 layerName*: array[VK_MAX_EXTENSION_NAME_SIZE, char] | |
| 4858 specVersion*: uint32 | |
| 4859 implementationVersion*: uint32 | |
| 4860 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 4861 VkApplicationInfo* = object | |
| 4862 sType*: VkStructureType | |
| 4863 pNext*: pointer | |
| 4864 pApplicationName*: cstring | |
| 4865 applicationVersion*: uint32 | |
| 4866 pEngineName*: cstring | |
| 4867 engineVersion*: uint32 | |
| 4868 apiVersion*: uint32 | |
| 4869 VkAllocationCallbacks* = object | |
| 4870 pUserData*: pointer | |
| 4871 pfnAllocation*: PFN_vkAllocationFunction | |
| 4872 pfnReallocation*: PFN_vkReallocationFunction | |
| 4873 pfnFree*: PFN_vkFreeFunction | |
| 4874 pfnInternalAllocation*: PFN_vkInternalAllocationNotification | |
| 4875 pfnInternalFree*: PFN_vkInternalFreeNotification | |
| 4876 VkDeviceQueueCreateInfo* = object | |
| 4877 sType*: VkStructureType | |
| 4878 pNext*: pointer | |
| 4879 flags*: VkDeviceQueueCreateFlags | |
| 4880 queueFamilyIndex*: uint32 | |
| 4881 queueCount*: uint32 | |
| 4882 pQueuePriorities*: ptr float32 | |
| 4883 VkDeviceCreateInfo* = object | |
| 4884 sType*: VkStructureType | |
| 4885 pNext*: pointer | |
| 4886 flags*: VkDeviceCreateFlags | |
| 4887 queueCreateInfoCount*: uint32 | |
| 4888 pQueueCreateInfos*: ptr VkDeviceQueueCreateInfo | |
| 4889 enabledLayerCount*: uint32 | |
| 4890 ppEnabledLayerNames*: cstringArray | |
| 4891 enabledExtensionCount*: uint32 | |
| 4892 ppEnabledExtensionNames*: cstringArray | |
| 4893 pEnabledFeatures*: ptr VkPhysicalDeviceFeatures | |
| 4894 VkInstanceCreateInfo* = object | |
| 4895 sType*: VkStructureType | |
| 4896 pNext*: pointer | |
| 4897 flags*: VkInstanceCreateFlags | |
| 4898 pApplicationInfo*: ptr VkApplicationInfo | |
| 4899 enabledLayerCount*: uint32 | |
| 4900 ppEnabledLayerNames*: cstringArray | |
| 4901 enabledExtensionCount*: uint32 | |
| 4902 ppEnabledExtensionNames*: cstringArray | |
| 4903 VkQueueFamilyProperties* = object | |
| 4904 queueFlags*: VkQueueFlags | |
| 4905 queueCount*: uint32 | |
| 4906 timestampValidBits*: uint32 | |
| 4907 minImageTransferGranularity*: VkExtent3D | |
| 4908 VkPhysicalDeviceMemoryProperties* = object | |
| 4909 memoryTypeCount*: uint32 | |
| 4910 memoryTypes*: array[VK_MAX_MEMORY_TYPES, VkMemoryType] | |
| 4911 memoryHeapCount*: uint32 | |
| 4912 memoryHeaps*: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap] | |
| 4913 VkMemoryAllocateInfo* = object | |
| 4914 sType*: VkStructureType | |
| 4915 pNext*: pointer | |
| 4916 allocationSize*: VkDeviceSize | |
| 4917 memoryTypeIndex*: uint32 | |
| 4918 VkMemoryRequirements* = object | |
| 4919 size*: VkDeviceSize | |
| 4920 alignment*: VkDeviceSize | |
| 4921 memoryTypeBits*: uint32 | |
| 4922 VkSparseImageFormatProperties* = object | |
| 4923 aspectMask*: VkImageAspectFlags | |
| 4924 imageGranularity*: VkExtent3D | |
| 4925 flags*: VkSparseImageFormatFlags | |
| 4926 VkSparseImageMemoryRequirements* = object | |
| 4927 formatProperties*: VkSparseImageFormatProperties | |
| 4928 imageMipTailFirstLod*: uint32 | |
| 4929 imageMipTailSize*: VkDeviceSize | |
| 4930 imageMipTailOffset*: VkDeviceSize | |
| 4931 imageMipTailStride*: VkDeviceSize | |
| 4932 VkMemoryType* = object | |
| 4933 propertyFlags*: VkMemoryPropertyFlags | |
| 4934 heapIndex*: uint32 | |
| 4935 VkMemoryHeap* = object | |
| 4936 size*: VkDeviceSize | |
| 4937 flags*: VkMemoryHeapFlags | |
| 4938 VkMappedMemoryRange* = object | |
| 4939 sType*: VkStructureType | |
| 4940 pNext*: pointer | |
| 4941 memory*: VkDeviceMemory | |
| 4942 offset*: VkDeviceSize | |
| 4943 size*: VkDeviceSize | |
| 4944 VkFormatProperties* = object | |
| 4945 linearTilingFeatures*: VkFormatFeatureFlags | |
| 4946 optimalTilingFeatures*: VkFormatFeatureFlags | |
| 4947 bufferFeatures*: VkFormatFeatureFlags | |
| 4948 VkImageFormatProperties* = object | |
| 4949 maxExtent*: VkExtent3D | |
| 4950 maxMipLevels*: uint32 | |
| 4951 maxArrayLayers*: uint32 | |
| 4952 sampleCounts*: VkSampleCountFlags | |
| 4953 maxResourceSize*: VkDeviceSize | |
| 4954 VkDescriptorBufferInfo* = object | |
| 4955 buffer*: VkBuffer | |
| 4956 offset*: VkDeviceSize | |
| 4957 range*: VkDeviceSize | |
| 4958 VkDescriptorImageInfo* = object | |
| 4959 sampler*: VkSampler | |
| 4960 imageView*: VkImageView | |
| 4961 imageLayout*: VkImageLayout | |
| 4962 VkWriteDescriptorSet* = object | |
| 4963 sType*: VkStructureType | |
| 4964 pNext*: pointer | |
| 4965 dstSet*: VkDescriptorSet | |
| 4966 dstBinding*: uint32 | |
| 4967 dstArrayElement*: uint32 | |
| 4968 descriptorCount*: uint32 | |
| 4969 descriptorType*: VkDescriptorType | |
| 4970 pImageInfo*: ptr VkDescriptorImageInfo | |
| 4971 pBufferInfo*: ptr VkDescriptorBufferInfo | |
| 4972 pTexelBufferView*: ptr VkBufferView | |
| 4973 VkCopyDescriptorSet* = object | |
| 4974 sType*: VkStructureType | |
| 4975 pNext*: pointer | |
| 4976 srcSet*: VkDescriptorSet | |
| 4977 srcBinding*: uint32 | |
| 4978 srcArrayElement*: uint32 | |
| 4979 dstSet*: VkDescriptorSet | |
| 4980 dstBinding*: uint32 | |
| 4981 dstArrayElement*: uint32 | |
| 4982 descriptorCount*: uint32 | |
| 4983 VkBufferCreateInfo* = object | |
| 4984 sType*: VkStructureType | |
| 4985 pNext*: pointer | |
| 4986 flags*: VkBufferCreateFlags | |
| 4987 size*: VkDeviceSize | |
| 4988 usage*: VkBufferUsageFlags | |
| 4989 sharingMode*: VkSharingMode | |
| 4990 queueFamilyIndexCount*: uint32 | |
| 4991 pQueueFamilyIndices*: ptr uint32 | |
| 4992 VkBufferViewCreateInfo* = object | |
| 4993 sType*: VkStructureType | |
| 4994 pNext*: pointer | |
| 4995 flags*: VkBufferViewCreateFlags | |
| 4996 buffer*: VkBuffer | |
| 4997 format*: VkFormat | |
| 4998 offset*: VkDeviceSize | |
| 4999 range*: VkDeviceSize | |
| 5000 VkImageSubresource* = object | |
| 5001 aspectMask*: VkImageAspectFlags | |
| 5002 mipLevel*: uint32 | |
| 5003 arrayLayer*: uint32 | |
| 5004 VkImageSubresourceLayers* = object | |
| 5005 aspectMask*: VkImageAspectFlags | |
| 5006 mipLevel*: uint32 | |
| 5007 baseArrayLayer*: uint32 | |
| 5008 layerCount*: uint32 | |
| 5009 VkImageSubresourceRange* = object | |
| 5010 aspectMask*: VkImageAspectFlags | |
| 5011 baseMipLevel*: uint32 | |
| 5012 levelCount*: uint32 | |
| 5013 baseArrayLayer*: uint32 | |
| 5014 layerCount*: uint32 | |
| 5015 VkMemoryBarrier* = object | |
| 5016 sType*: VkStructureType | |
| 5017 pNext*: pointer | |
| 5018 srcAccessMask*: VkAccessFlags | |
| 5019 dstAccessMask*: VkAccessFlags | |
| 5020 VkBufferMemoryBarrier* = object | |
| 5021 sType*: VkStructureType | |
| 5022 pNext*: pointer | |
| 5023 srcAccessMask*: VkAccessFlags | |
| 5024 dstAccessMask*: VkAccessFlags | |
| 5025 srcQueueFamilyIndex*: uint32 | |
| 5026 dstQueueFamilyIndex*: uint32 | |
| 5027 buffer*: VkBuffer | |
| 5028 offset*: VkDeviceSize | |
| 5029 size*: VkDeviceSize | |
| 5030 VkImageMemoryBarrier* = object | |
| 5031 sType*: VkStructureType | |
| 5032 pNext*: pointer | |
| 5033 srcAccessMask*: VkAccessFlags | |
| 5034 dstAccessMask*: VkAccessFlags | |
| 5035 oldLayout*: VkImageLayout | |
| 5036 newLayout*: VkImageLayout | |
| 5037 srcQueueFamilyIndex*: uint32 | |
| 5038 dstQueueFamilyIndex*: uint32 | |
| 5039 image*: VkImage | |
| 5040 subresourceRange*: VkImageSubresourceRange | |
| 5041 VkImageCreateInfo* = object | |
| 5042 sType*: VkStructureType | |
| 5043 pNext*: pointer | |
| 5044 flags*: VkImageCreateFlags | |
| 5045 imageType*: VkImageType | |
| 5046 format*: VkFormat | |
| 5047 extent*: VkExtent3D | |
| 5048 mipLevels*: uint32 | |
| 5049 arrayLayers*: uint32 | |
| 5050 samples*: VkSampleCountFlagBits | |
| 5051 tiling*: VkImageTiling | |
| 5052 usage*: VkImageUsageFlags | |
| 5053 sharingMode*: VkSharingMode | |
| 5054 queueFamilyIndexCount*: uint32 | |
| 5055 pQueueFamilyIndices*: ptr uint32 | |
| 5056 initialLayout*: VkImageLayout | |
| 5057 VkSubresourceLayout* = object | |
| 5058 offset*: VkDeviceSize | |
| 5059 size*: VkDeviceSize | |
| 5060 rowPitch*: VkDeviceSize | |
| 5061 arrayPitch*: VkDeviceSize | |
| 5062 depthPitch*: VkDeviceSize | |
| 5063 VkImageViewCreateInfo* = object | |
| 5064 sType*: VkStructureType | |
| 5065 pNext*: pointer | |
| 5066 flags*: VkImageViewCreateFlags | |
| 5067 image*: VkImage | |
| 5068 viewType*: VkImageViewType | |
| 5069 format*: VkFormat | |
| 5070 components*: VkComponentMapping | |
| 5071 subresourceRange*: VkImageSubresourceRange | |
| 5072 VkBufferCopy* = object | |
| 5073 srcOffset*: VkDeviceSize | |
| 5074 dstOffset*: VkDeviceSize | |
| 5075 size*: VkDeviceSize | |
| 5076 VkSparseMemoryBind* = object | |
| 5077 resourceOffset*: VkDeviceSize | |
| 5078 size*: VkDeviceSize | |
| 5079 memory*: VkDeviceMemory | |
| 5080 memoryOffset*: VkDeviceSize | |
| 5081 flags*: VkSparseMemoryBindFlags | |
| 5082 VkSparseImageMemoryBind* = object | |
| 5083 subresource*: VkImageSubresource | |
| 5084 offset*: VkOffset3D | |
| 5085 extent*: VkExtent3D | |
| 5086 memory*: VkDeviceMemory | |
| 5087 memoryOffset*: VkDeviceSize | |
| 5088 flags*: VkSparseMemoryBindFlags | |
| 5089 VkSparseBufferMemoryBindInfo* = object | |
| 5090 buffer*: VkBuffer | |
| 5091 bindCount*: uint32 | |
| 5092 pBinds*: ptr VkSparseMemoryBind | |
| 5093 VkSparseImageOpaqueMemoryBindInfo* = object | |
| 5094 image*: VkImage | |
| 5095 bindCount*: uint32 | |
| 5096 pBinds*: ptr VkSparseMemoryBind | |
| 5097 VkSparseImageMemoryBindInfo* = object | |
| 5098 image*: VkImage | |
| 5099 bindCount*: uint32 | |
| 5100 pBinds*: ptr VkSparseImageMemoryBind | |
| 5101 VkBindSparseInfo* = object | |
| 5102 sType*: VkStructureType | |
| 5103 pNext*: pointer | |
| 5104 waitSemaphoreCount*: uint32 | |
| 5105 pWaitSemaphores*: ptr VkSemaphore | |
| 5106 bufferBindCount*: uint32 | |
| 5107 pBufferBinds*: ptr VkSparseBufferMemoryBindInfo | |
| 5108 imageOpaqueBindCount*: uint32 | |
| 5109 pImageOpaqueBinds*: ptr VkSparseImageOpaqueMemoryBindInfo | |
| 5110 imageBindCount*: uint32 | |
| 5111 pImageBinds*: ptr VkSparseImageMemoryBindInfo | |
| 5112 signalSemaphoreCount*: uint32 | |
| 5113 pSignalSemaphores*: ptr VkSemaphore | |
| 5114 VkImageCopy* = object | |
| 5115 srcSubresource*: VkImageSubresourceLayers | |
| 5116 srcOffset*: VkOffset3D | |
| 5117 dstSubresource*: VkImageSubresourceLayers | |
| 5118 dstOffset*: VkOffset3D | |
| 5119 extent*: VkExtent3D | |
| 5120 VkImageBlit* = object | |
| 5121 srcSubresource*: VkImageSubresourceLayers | |
| 5122 srcOffsets*: array[2, VkOffset3D] | |
| 5123 dstSubresource*: VkImageSubresourceLayers | |
| 5124 dstOffsets*: array[2, VkOffset3D] | |
| 5125 VkBufferImageCopy* = object | |
| 5126 bufferOffset*: VkDeviceSize | |
| 5127 bufferRowLength*: uint32 | |
| 5128 bufferImageHeight*: uint32 | |
| 5129 imageSubresource*: VkImageSubresourceLayers | |
| 5130 imageOffset*: VkOffset3D | |
| 5131 imageExtent*: VkExtent3D | |
| 5132 VkCopyMemoryIndirectCommandNV* = object | |
| 5133 srcAddress*: VkDeviceAddress | |
| 5134 dstAddress*: VkDeviceAddress | |
| 5135 size*: VkDeviceSize | |
| 5136 VkCopyMemoryToImageIndirectCommandNV* = object | |
| 5137 srcAddress*: VkDeviceAddress | |
| 5138 bufferRowLength*: uint32 | |
| 5139 bufferImageHeight*: uint32 | |
| 5140 imageSubresource*: VkImageSubresourceLayers | |
| 5141 imageOffset*: VkOffset3D | |
| 5142 imageExtent*: VkExtent3D | |
| 5143 VkImageResolve* = object | |
| 5144 srcSubresource*: VkImageSubresourceLayers | |
| 5145 srcOffset*: VkOffset3D | |
| 5146 dstSubresource*: VkImageSubresourceLayers | |
| 5147 dstOffset*: VkOffset3D | |
| 5148 extent*: VkExtent3D | |
| 5149 VkShaderModuleCreateInfo* = object | |
| 5150 sType*: VkStructureType | |
| 5151 pNext*: pointer | |
| 5152 flags*: VkShaderModuleCreateFlags | |
| 5153 codeSize*: csize_t | |
| 5154 pCode*: ptr uint32 | |
| 5155 VkDescriptorSetLayoutBinding* = object | |
| 5156 binding*: uint32 | |
| 5157 descriptorType*: VkDescriptorType | |
| 5158 descriptorCount*: uint32 | |
| 5159 stageFlags*: VkShaderStageFlags | |
| 5160 pImmutableSamplers*: ptr VkSampler | |
| 5161 VkDescriptorSetLayoutCreateInfo* = object | |
| 5162 sType*: VkStructureType | |
| 5163 pNext*: pointer | |
| 5164 flags*: VkDescriptorSetLayoutCreateFlags | |
| 5165 bindingCount*: uint32 | |
| 5166 pBindings*: ptr VkDescriptorSetLayoutBinding | |
| 5167 VkDescriptorPoolSize* = object | |
| 5168 thetype*: VkDescriptorType | |
| 5169 descriptorCount*: uint32 | |
| 5170 VkDescriptorPoolCreateInfo* = object | |
| 5171 sType*: VkStructureType | |
| 5172 pNext*: pointer | |
| 5173 flags*: VkDescriptorPoolCreateFlags | |
| 5174 maxSets*: uint32 | |
| 5175 poolSizeCount*: uint32 | |
| 5176 pPoolSizes*: ptr VkDescriptorPoolSize | |
| 5177 VkDescriptorSetAllocateInfo* = object | |
| 5178 sType*: VkStructureType | |
| 5179 pNext*: pointer | |
| 5180 descriptorPool*: VkDescriptorPool | |
| 5181 descriptorSetCount*: uint32 | |
| 5182 pSetLayouts*: ptr VkDescriptorSetLayout | |
| 5183 VkSpecializationMapEntry* = object | |
| 5184 constantID*: uint32 | |
| 5185 offset*: uint32 | |
| 5186 size*: csize_t | |
| 5187 VkSpecializationInfo* = object | |
| 5188 mapEntryCount*: uint32 | |
| 5189 pMapEntries*: ptr VkSpecializationMapEntry | |
| 5190 dataSize*: csize_t | |
| 5191 pData*: pointer | |
| 5192 VkPipelineShaderStageCreateInfo* = object | |
| 5193 sType*: VkStructureType | |
| 5194 pNext*: pointer | |
| 5195 flags*: VkPipelineShaderStageCreateFlags | |
| 5196 stage*: VkShaderStageFlagBits | |
| 5197 module*: VkShaderModule | |
| 5198 pName*: cstring | |
| 5199 pSpecializationInfo*: ptr VkSpecializationInfo | |
| 5200 VkComputePipelineCreateInfo* = object | |
| 5201 sType*: VkStructureType | |
| 5202 pNext*: pointer | |
| 5203 flags*: VkPipelineCreateFlags | |
| 5204 stage*: VkPipelineShaderStageCreateInfo | |
| 5205 layout*: VkPipelineLayout | |
| 5206 basePipelineHandle*: VkPipeline | |
| 5207 basePipelineIndex*: int32 | |
| 5208 VkVertexInputBindingDescription* = object | |
| 5209 binding*: uint32 | |
| 5210 stride*: uint32 | |
| 5211 inputRate*: VkVertexInputRate | |
| 5212 VkVertexInputAttributeDescription* = object | |
| 5213 location*: uint32 | |
| 5214 binding*: uint32 | |
| 5215 format*: VkFormat | |
| 5216 offset*: uint32 | |
| 5217 VkPipelineVertexInputStateCreateInfo* = object | |
| 5218 sType*: VkStructureType | |
| 5219 pNext*: pointer | |
| 5220 flags*: VkPipelineVertexInputStateCreateFlags | |
| 5221 vertexBindingDescriptionCount*: uint32 | |
| 5222 pVertexBindingDescriptions*: ptr VkVertexInputBindingDescription | |
| 5223 vertexAttributeDescriptionCount*: uint32 | |
| 5224 pVertexAttributeDescriptions*: ptr VkVertexInputAttributeDescription | |
| 5225 VkPipelineInputAssemblyStateCreateInfo* = object | |
| 5226 sType*: VkStructureType | |
| 5227 pNext*: pointer | |
| 5228 flags*: VkPipelineInputAssemblyStateCreateFlags | |
| 5229 topology*: VkPrimitiveTopology | |
| 5230 primitiveRestartEnable*: VkBool32 | |
| 5231 VkPipelineTessellationStateCreateInfo* = object | |
| 5232 sType*: VkStructureType | |
| 5233 pNext*: pointer | |
| 5234 flags*: VkPipelineTessellationStateCreateFlags | |
| 5235 patchControlPoints*: uint32 | |
| 5236 VkPipelineViewportStateCreateInfo* = object | |
| 5237 sType*: VkStructureType | |
| 5238 pNext*: pointer | |
| 5239 flags*: VkPipelineViewportStateCreateFlags | |
| 5240 viewportCount*: uint32 | |
| 5241 pViewports*: ptr VkViewport | |
| 5242 scissorCount*: uint32 | |
| 5243 pScissors*: ptr VkRect2D | |
| 5244 VkPipelineRasterizationStateCreateInfo* = object | |
| 5245 sType*: VkStructureType | |
| 5246 pNext*: pointer | |
| 5247 flags*: VkPipelineRasterizationStateCreateFlags | |
| 5248 depthClampEnable*: VkBool32 | |
| 5249 rasterizerDiscardEnable*: VkBool32 | |
| 5250 polygonMode*: VkPolygonMode | |
| 5251 cullMode*: VkCullModeFlags | |
| 5252 frontFace*: VkFrontFace | |
| 5253 depthBiasEnable*: VkBool32 | |
| 5254 depthBiasConstantFactor*: float32 | |
| 5255 depthBiasClamp*: float32 | |
| 5256 depthBiasSlopeFactor*: float32 | |
| 5257 lineWidth*: float32 | |
| 5258 VkPipelineMultisampleStateCreateInfo* = object | |
| 5259 sType*: VkStructureType | |
| 5260 pNext*: pointer | |
| 5261 flags*: VkPipelineMultisampleStateCreateFlags | |
| 5262 rasterizationSamples*: VkSampleCountFlagBits | |
| 5263 sampleShadingEnable*: VkBool32 | |
| 5264 minSampleShading*: float32 | |
| 5265 pSampleMask*: ptr VkSampleMask | |
| 5266 alphaToCoverageEnable*: VkBool32 | |
| 5267 alphaToOneEnable*: VkBool32 | |
| 5268 VkPipelineColorBlendAttachmentState* = object | |
| 5269 blendEnable*: VkBool32 | |
| 5270 srcColorBlendFactor*: VkBlendFactor | |
| 5271 dstColorBlendFactor*: VkBlendFactor | |
| 5272 colorBlendOp*: VkBlendOp | |
| 5273 srcAlphaBlendFactor*: VkBlendFactor | |
| 5274 dstAlphaBlendFactor*: VkBlendFactor | |
| 5275 alphaBlendOp*: VkBlendOp | |
| 5276 colorWriteMask*: VkColorComponentFlags | |
| 5277 VkPipelineColorBlendStateCreateInfo* = object | |
| 5278 sType*: VkStructureType | |
| 5279 pNext*: pointer | |
| 5280 flags*: VkPipelineColorBlendStateCreateFlags | |
| 5281 logicOpEnable*: VkBool32 | |
| 5282 logicOp*: VkLogicOp | |
| 5283 attachmentCount*: uint32 | |
| 5284 pAttachments*: ptr VkPipelineColorBlendAttachmentState | |
| 5285 blendConstants*: array[4, float32] | |
| 5286 VkPipelineDynamicStateCreateInfo* = object | |
| 5287 sType*: VkStructureType | |
| 5288 pNext*: pointer | |
| 5289 flags*: VkPipelineDynamicStateCreateFlags | |
| 5290 dynamicStateCount*: uint32 | |
| 5291 pDynamicStates*: ptr VkDynamicState | |
| 5292 VkStencilOpState* = object | |
| 5293 failOp*: VkStencilOp | |
| 5294 passOp*: VkStencilOp | |
| 5295 depthFailOp*: VkStencilOp | |
| 5296 compareOp*: VkCompareOp | |
| 5297 compareMask*: uint32 | |
| 5298 writeMask*: uint32 | |
| 5299 reference*: uint32 | |
| 5300 VkPipelineDepthStencilStateCreateInfo* = object | |
| 5301 sType*: VkStructureType | |
| 5302 pNext*: pointer | |
| 5303 flags*: VkPipelineDepthStencilStateCreateFlags | |
| 5304 depthTestEnable*: VkBool32 | |
| 5305 depthWriteEnable*: VkBool32 | |
| 5306 depthCompareOp*: VkCompareOp | |
| 5307 depthBoundsTestEnable*: VkBool32 | |
| 5308 stencilTestEnable*: VkBool32 | |
| 5309 front*: VkStencilOpState | |
| 5310 back*: VkStencilOpState | |
| 5311 minDepthBounds*: float32 | |
| 5312 maxDepthBounds*: float32 | |
| 5313 VkGraphicsPipelineCreateInfo* = object | |
| 5314 sType*: VkStructureType | |
| 5315 pNext*: pointer | |
| 5316 flags*: VkPipelineCreateFlags | |
| 5317 stageCount*: uint32 | |
| 5318 pStages*: ptr VkPipelineShaderStageCreateInfo | |
| 5319 pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo | |
| 5320 pInputAssemblyState*: ptr VkPipelineInputAssemblyStateCreateInfo | |
| 5321 pTessellationState*: ptr VkPipelineTessellationStateCreateInfo | |
| 5322 pViewportState*: ptr VkPipelineViewportStateCreateInfo | |
| 5323 pRasterizationState*: ptr VkPipelineRasterizationStateCreateInfo | |
| 5324 pMultisampleState*: ptr VkPipelineMultisampleStateCreateInfo | |
| 5325 pDepthStencilState*: ptr VkPipelineDepthStencilStateCreateInfo | |
| 5326 pColorBlendState*: ptr VkPipelineColorBlendStateCreateInfo | |
| 5327 pDynamicState*: ptr VkPipelineDynamicStateCreateInfo | |
| 5328 layout*: VkPipelineLayout | |
| 5329 renderPass*: VkRenderPass | |
| 5330 subpass*: uint32 | |
| 5331 basePipelineHandle*: VkPipeline | |
| 5332 basePipelineIndex*: int32 | |
| 5333 VkPipelineCacheCreateInfo* = object | |
| 5334 sType*: VkStructureType | |
| 5335 pNext*: pointer | |
| 5336 flags*: VkPipelineCacheCreateFlags | |
| 5337 initialDataSize*: csize_t | |
| 5338 pInitialData*: pointer | |
| 5339 VkPipelineCacheHeaderVersionOne* = object | |
| 5340 headerSize*: uint32 | |
| 5341 headerVersion*: VkPipelineCacheHeaderVersion | |
| 5342 vendorID*: uint32 | |
| 5343 deviceID*: uint32 | |
| 5344 pipelineCacheUUID*: array[VK_UUID_SIZE, uint8] | |
| 5345 VkPipelineCacheStageValidationIndexEntry* = object | |
| 5346 codeSize*: uint64 | |
| 5347 codeOffset*: uint64 | |
| 5348 VkPipelineCacheSafetyCriticalIndexEntry* = object | |
| 5349 pipelineIdentifier*: array[VK_UUID_SIZE, uint8] | |
| 5350 pipelineMemorySize*: uint64 | |
| 5351 jsonSize*: uint64 | |
| 5352 jsonOffset*: uint64 | |
| 5353 stageIndexCount*: uint32 | |
| 5354 stageIndexStride*: uint32 | |
| 5355 stageIndexOffset*: uint64 | |
| 5356 VkPipelineCacheHeaderVersionSafetyCriticalOne* = object | |
| 5357 headerVersionOne*: VkPipelineCacheHeaderVersionOne | |
| 5358 validationVersion*: VkPipelineCacheValidationVersion | |
| 5359 implementationData*: uint32 | |
| 5360 pipelineIndexCount*: uint32 | |
| 5361 pipelineIndexStride*: uint32 | |
| 5362 pipelineIndexOffset*: uint64 | |
| 5363 VkPushConstantRange* = object | |
| 5364 stageFlags*: VkShaderStageFlags | |
| 5365 offset*: uint32 | |
| 5366 size*: uint32 | |
| 5367 VkPipelineLayoutCreateInfo* = object | |
| 5368 sType*: VkStructureType | |
| 5369 pNext*: pointer | |
| 5370 flags*: VkPipelineLayoutCreateFlags | |
| 5371 setLayoutCount*: uint32 | |
| 5372 pSetLayouts*: ptr VkDescriptorSetLayout | |
| 5373 pushConstantRangeCount*: uint32 | |
| 5374 pPushConstantRanges*: ptr VkPushConstantRange | |
| 5375 VkSamplerCreateInfo* = object | |
| 5376 sType*: VkStructureType | |
| 5377 pNext*: pointer | |
| 5378 flags*: VkSamplerCreateFlags | |
| 5379 magFilter*: VkFilter | |
| 5380 minFilter*: VkFilter | |
| 5381 mipmapMode*: VkSamplerMipmapMode | |
| 5382 addressModeU*: VkSamplerAddressMode | |
| 5383 addressModeV*: VkSamplerAddressMode | |
| 5384 addressModeW*: VkSamplerAddressMode | |
| 5385 mipLodBias*: float32 | |
| 5386 anisotropyEnable*: VkBool32 | |
| 5387 maxAnisotropy*: float32 | |
| 5388 compareEnable*: VkBool32 | |
| 5389 compareOp*: VkCompareOp | |
| 5390 minLod*: float32 | |
| 5391 maxLod*: float32 | |
| 5392 borderColor*: VkBorderColor | |
| 5393 unnormalizedCoordinates*: VkBool32 | |
| 5394 VkCommandPoolCreateInfo* = object | |
| 5395 sType*: VkStructureType | |
| 5396 pNext*: pointer | |
| 5397 flags*: VkCommandPoolCreateFlags | |
| 5398 queueFamilyIndex*: uint32 | |
| 5399 VkCommandBufferAllocateInfo* = object | |
| 5400 sType*: VkStructureType | |
| 5401 pNext*: pointer | |
| 5402 commandPool*: VkCommandPool | |
| 5403 level*: VkCommandBufferLevel | |
| 5404 commandBufferCount*: uint32 | |
| 5405 VkCommandBufferInheritanceInfo* = object | |
| 5406 sType*: VkStructureType | |
| 5407 pNext*: pointer | |
| 5408 renderPass*: VkRenderPass | |
| 5409 subpass*: uint32 | |
| 5410 framebuffer*: VkFramebuffer | |
| 5411 occlusionQueryEnable*: VkBool32 | |
| 5412 queryFlags*: VkQueryControlFlags | |
| 5413 pipelineStatistics*: VkQueryPipelineStatisticFlags | |
| 5414 VkCommandBufferBeginInfo* = object | |
| 5415 sType*: VkStructureType | |
| 5416 pNext*: pointer | |
| 5417 flags*: VkCommandBufferUsageFlags | |
| 5418 pInheritanceInfo*: ptr VkCommandBufferInheritanceInfo | |
| 5419 VkRenderPassBeginInfo* = object | |
| 5420 sType*: VkStructureType | |
| 5421 pNext*: pointer | |
| 5422 renderPass*: VkRenderPass | |
| 5423 framebuffer*: VkFramebuffer | |
| 5424 renderArea*: VkRect2D | |
| 5425 clearValueCount*: uint32 | |
| 5426 pClearValues*: ptr VkClearValue | |
| 5427 VkClearColorValue* {.union.} = object | |
| 5428 float32*: array[4, float32] | |
| 5429 int32*: array[4, int32] | |
| 5430 uint32*: array[4, uint32] | |
| 5431 VkClearDepthStencilValue* = object | |
| 5432 depth*: float32 | |
| 5433 stencil*: uint32 | |
| 5434 VkClearValue* {.union.} = object | |
| 5435 color*: VkClearColorValue | |
| 5436 depthStencil*: VkClearDepthStencilValue | |
| 5437 VkClearAttachment* = object | |
| 5438 aspectMask*: VkImageAspectFlags | |
| 5439 colorAttachment*: uint32 | |
| 5440 clearValue*: VkClearValue | |
| 5441 VkAttachmentDescription* = object | |
| 5442 flags*: VkAttachmentDescriptionFlags | |
| 5443 format*: VkFormat | |
| 5444 samples*: VkSampleCountFlagBits | |
| 5445 loadOp*: VkAttachmentLoadOp | |
| 5446 storeOp*: VkAttachmentStoreOp | |
| 5447 stencilLoadOp*: VkAttachmentLoadOp | |
| 5448 stencilStoreOp*: VkAttachmentStoreOp | |
| 5449 initialLayout*: VkImageLayout | |
| 5450 finalLayout*: VkImageLayout | |
| 5451 VkAttachmentReference* = object | |
| 5452 attachment*: uint32 | |
| 5453 layout*: VkImageLayout | |
| 5454 VkSubpassDescription* = object | |
| 5455 flags*: VkSubpassDescriptionFlags | |
| 5456 pipelineBindPoint*: VkPipelineBindPoint | |
| 5457 inputAttachmentCount*: uint32 | |
| 5458 pInputAttachments*: ptr VkAttachmentReference | |
| 5459 colorAttachmentCount*: uint32 | |
| 5460 pColorAttachments*: ptr VkAttachmentReference | |
| 5461 pResolveAttachments*: ptr VkAttachmentReference | |
| 5462 pDepthStencilAttachment*: ptr VkAttachmentReference | |
| 5463 preserveAttachmentCount*: uint32 | |
| 5464 pPreserveAttachments*: ptr uint32 | |
| 5465 VkSubpassDependency* = object | |
| 5466 srcSubpass*: uint32 | |
| 5467 dstSubpass*: uint32 | |
| 5468 srcStageMask*: VkPipelineStageFlags | |
| 5469 dstStageMask*: VkPipelineStageFlags | |
| 5470 srcAccessMask*: VkAccessFlags | |
| 5471 dstAccessMask*: VkAccessFlags | |
| 5472 dependencyFlags*: VkDependencyFlags | |
| 5473 VkRenderPassCreateInfo* = object | |
| 5474 sType*: VkStructureType | |
| 5475 pNext*: pointer | |
| 5476 flags*: VkRenderPassCreateFlags | |
| 5477 attachmentCount*: uint32 | |
| 5478 pAttachments*: ptr VkAttachmentDescription | |
| 5479 subpassCount*: uint32 | |
| 5480 pSubpasses*: ptr VkSubpassDescription | |
| 5481 dependencyCount*: uint32 | |
| 5482 pDependencies*: ptr VkSubpassDependency | |
| 5483 VkEventCreateInfo* = object | |
| 5484 sType*: VkStructureType | |
| 5485 pNext*: pointer | |
| 5486 flags*: VkEventCreateFlags | |
| 5487 VkFenceCreateInfo* = object | |
| 5488 sType*: VkStructureType | |
| 5489 pNext*: pointer | |
| 5490 flags*: VkFenceCreateFlags | |
| 5491 VkPhysicalDeviceFeatures* = object | |
| 5492 robustBufferAccess*: VkBool32 | |
| 5493 fullDrawIndexUint32*: VkBool32 | |
| 5494 imageCubeArray*: VkBool32 | |
| 5495 independentBlend*: VkBool32 | |
| 5496 geometryShader*: VkBool32 | |
| 5497 tessellationShader*: VkBool32 | |
| 5498 sampleRateShading*: VkBool32 | |
| 5499 dualSrcBlend*: VkBool32 | |
| 5500 logicOp*: VkBool32 | |
| 5501 multiDrawIndirect*: VkBool32 | |
| 5502 drawIndirectFirstInstance*: VkBool32 | |
| 5503 depthClamp*: VkBool32 | |
| 5504 depthBiasClamp*: VkBool32 | |
| 5505 fillModeNonSolid*: VkBool32 | |
| 5506 depthBounds*: VkBool32 | |
| 5507 wideLines*: VkBool32 | |
| 5508 largePoints*: VkBool32 | |
| 5509 alphaToOne*: VkBool32 | |
| 5510 multiViewport*: VkBool32 | |
| 5511 samplerAnisotropy*: VkBool32 | |
| 5512 textureCompressionETC2*: VkBool32 | |
| 5513 textureCompressionASTC_LDR*: VkBool32 | |
| 5514 textureCompressionBC*: VkBool32 | |
| 5515 occlusionQueryPrecise*: VkBool32 | |
| 5516 pipelineStatisticsQuery*: VkBool32 | |
| 5517 vertexPipelineStoresAndAtomics*: VkBool32 | |
| 5518 fragmentStoresAndAtomics*: VkBool32 | |
| 5519 shaderTessellationAndGeometryPointSize*: VkBool32 | |
| 5520 shaderImageGatherExtended*: VkBool32 | |
| 5521 shaderStorageImageExtendedFormats*: VkBool32 | |
| 5522 shaderStorageImageMultisample*: VkBool32 | |
| 5523 shaderStorageImageReadWithoutFormat*: VkBool32 | |
| 5524 shaderStorageImageWriteWithoutFormat*: VkBool32 | |
| 5525 shaderUniformBufferArrayDynamicIndexing*: VkBool32 | |
| 5526 shaderSampledImageArrayDynamicIndexing*: VkBool32 | |
| 5527 shaderStorageBufferArrayDynamicIndexing*: VkBool32 | |
| 5528 shaderStorageImageArrayDynamicIndexing*: VkBool32 | |
| 5529 shaderClipDistance*: VkBool32 | |
| 5530 shaderCullDistance*: VkBool32 | |
| 5531 shaderFloat64*: VkBool32 | |
| 5532 shaderInt64*: VkBool32 | |
| 5533 shaderInt16*: VkBool32 | |
| 5534 shaderResourceResidency*: VkBool32 | |
| 5535 shaderResourceMinLod*: VkBool32 | |
| 5536 sparseBinding*: VkBool32 | |
| 5537 sparseResidencyBuffer*: VkBool32 | |
| 5538 sparseResidencyImage2D*: VkBool32 | |
| 5539 sparseResidencyImage3D*: VkBool32 | |
| 5540 sparseResidency2Samples*: VkBool32 | |
| 5541 sparseResidency4Samples*: VkBool32 | |
| 5542 sparseResidency8Samples*: VkBool32 | |
| 5543 sparseResidency16Samples*: VkBool32 | |
| 5544 sparseResidencyAliased*: VkBool32 | |
| 5545 variableMultisampleRate*: VkBool32 | |
| 5546 inheritedQueries*: VkBool32 | |
| 5547 VkPhysicalDeviceSparseProperties* = object | |
| 5548 residencyStandard2DBlockShape*: VkBool32 | |
| 5549 residencyStandard2DMultisampleBlockShape*: VkBool32 | |
| 5550 residencyStandard3DBlockShape*: VkBool32 | |
| 5551 residencyAlignedMipSize*: VkBool32 | |
| 5552 residencyNonResidentStrict*: VkBool32 | |
| 5553 VkPhysicalDeviceLimits* = object | |
| 5554 maxImageDimension1D*: uint32 | |
| 5555 maxImageDimension2D*: uint32 | |
| 5556 maxImageDimension3D*: uint32 | |
| 5557 maxImageDimensionCube*: uint32 | |
| 5558 maxImageArrayLayers*: uint32 | |
| 5559 maxTexelBufferElements*: uint32 | |
| 5560 maxUniformBufferRange*: uint32 | |
| 5561 maxStorageBufferRange*: uint32 | |
| 5562 maxPushConstantsSize*: uint32 | |
| 5563 maxMemoryAllocationCount*: uint32 | |
| 5564 maxSamplerAllocationCount*: uint32 | |
| 5565 bufferImageGranularity*: VkDeviceSize | |
| 5566 sparseAddressSpaceSize*: VkDeviceSize | |
| 5567 maxBoundDescriptorSets*: uint32 | |
| 5568 maxPerStageDescriptorSamplers*: uint32 | |
| 5569 maxPerStageDescriptorUniformBuffers*: uint32 | |
| 5570 maxPerStageDescriptorStorageBuffers*: uint32 | |
| 5571 maxPerStageDescriptorSampledImages*: uint32 | |
| 5572 maxPerStageDescriptorStorageImages*: uint32 | |
| 5573 maxPerStageDescriptorInputAttachments*: uint32 | |
| 5574 maxPerStageResources*: uint32 | |
| 5575 maxDescriptorSetSamplers*: uint32 | |
| 5576 maxDescriptorSetUniformBuffers*: uint32 | |
| 5577 maxDescriptorSetUniformBuffersDynamic*: uint32 | |
| 5578 maxDescriptorSetStorageBuffers*: uint32 | |
| 5579 maxDescriptorSetStorageBuffersDynamic*: uint32 | |
| 5580 maxDescriptorSetSampledImages*: uint32 | |
| 5581 maxDescriptorSetStorageImages*: uint32 | |
| 5582 maxDescriptorSetInputAttachments*: uint32 | |
| 5583 maxVertexInputAttributes*: uint32 | |
| 5584 maxVertexInputBindings*: uint32 | |
| 5585 maxVertexInputAttributeOffset*: uint32 | |
| 5586 maxVertexInputBindingStride*: uint32 | |
| 5587 maxVertexOutputComponents*: uint32 | |
| 5588 maxTessellationGenerationLevel*: uint32 | |
| 5589 maxTessellationPatchSize*: uint32 | |
| 5590 maxTessellationControlPerVertexInputComponents*: uint32 | |
| 5591 maxTessellationControlPerVertexOutputComponents*: uint32 | |
| 5592 maxTessellationControlPerPatchOutputComponents*: uint32 | |
| 5593 maxTessellationControlTotalOutputComponents*: uint32 | |
| 5594 maxTessellationEvaluationInputComponents*: uint32 | |
| 5595 maxTessellationEvaluationOutputComponents*: uint32 | |
| 5596 maxGeometryShaderInvocations*: uint32 | |
| 5597 maxGeometryInputComponents*: uint32 | |
| 5598 maxGeometryOutputComponents*: uint32 | |
| 5599 maxGeometryOutputVertices*: uint32 | |
| 5600 maxGeometryTotalOutputComponents*: uint32 | |
| 5601 maxFragmentInputComponents*: uint32 | |
| 5602 maxFragmentOutputAttachments*: uint32 | |
| 5603 maxFragmentDualSrcAttachments*: uint32 | |
| 5604 maxFragmentCombinedOutputResources*: uint32 | |
| 5605 maxComputeSharedMemorySize*: uint32 | |
| 5606 maxComputeWorkGroupCount*: array[3, uint32] | |
| 5607 maxComputeWorkGroupInvocations*: uint32 | |
| 5608 maxComputeWorkGroupSize*: array[3, uint32] | |
| 5609 subPixelPrecisionBits*: uint32 | |
| 5610 subTexelPrecisionBits*: uint32 | |
| 5611 mipmapPrecisionBits*: uint32 | |
| 5612 maxDrawIndexedIndexValue*: uint32 | |
| 5613 maxDrawIndirectCount*: uint32 | |
| 5614 maxSamplerLodBias*: float32 | |
| 5615 maxSamplerAnisotropy*: float32 | |
| 5616 maxViewports*: uint32 | |
| 5617 maxViewportDimensions*: array[2, uint32] | |
| 5618 viewportBoundsRange*: array[2, float32] | |
| 5619 viewportSubPixelBits*: uint32 | |
| 5620 minMemoryMapAlignment*: csize_t | |
| 5621 minTexelBufferOffsetAlignment*: VkDeviceSize | |
| 5622 minUniformBufferOffsetAlignment*: VkDeviceSize | |
| 5623 minStorageBufferOffsetAlignment*: VkDeviceSize | |
| 5624 minTexelOffset*: int32 | |
| 5625 maxTexelOffset*: uint32 | |
| 5626 minTexelGatherOffset*: int32 | |
| 5627 maxTexelGatherOffset*: uint32 | |
| 5628 minInterpolationOffset*: float32 | |
| 5629 maxInterpolationOffset*: float32 | |
| 5630 subPixelInterpolationOffsetBits*: uint32 | |
| 5631 maxFramebufferWidth*: uint32 | |
| 5632 maxFramebufferHeight*: uint32 | |
| 5633 maxFramebufferLayers*: uint32 | |
| 5634 framebufferColorSampleCounts*: VkSampleCountFlags | |
| 5635 framebufferDepthSampleCounts*: VkSampleCountFlags | |
| 5636 framebufferStencilSampleCounts*: VkSampleCountFlags | |
| 5637 framebufferNoAttachmentsSampleCounts*: VkSampleCountFlags | |
| 5638 maxColorAttachments*: uint32 | |
| 5639 sampledImageColorSampleCounts*: VkSampleCountFlags | |
| 5640 sampledImageIntegerSampleCounts*: VkSampleCountFlags | |
| 5641 sampledImageDepthSampleCounts*: VkSampleCountFlags | |
| 5642 sampledImageStencilSampleCounts*: VkSampleCountFlags | |
| 5643 storageImageSampleCounts*: VkSampleCountFlags | |
| 5644 maxSampleMaskWords*: uint32 | |
| 5645 timestampComputeAndGraphics*: VkBool32 | |
| 5646 timestampPeriod*: float32 | |
| 5647 maxClipDistances*: uint32 | |
| 5648 maxCullDistances*: uint32 | |
| 5649 maxCombinedClipAndCullDistances*: uint32 | |
| 5650 discreteQueuePriorities*: uint32 | |
| 5651 pointSizeRange*: array[2, float32] | |
| 5652 lineWidthRange*: array[2, float32] | |
| 5653 pointSizeGranularity*: float32 | |
| 5654 lineWidthGranularity*: float32 | |
| 5655 strictLines*: VkBool32 | |
| 5656 standardSampleLocations*: VkBool32 | |
| 5657 optimalBufferCopyOffsetAlignment*: VkDeviceSize | |
| 5658 optimalBufferCopyRowPitchAlignment*: VkDeviceSize | |
| 5659 nonCoherentAtomSize*: VkDeviceSize | |
| 5660 VkSemaphoreCreateInfo* = object | |
| 5661 sType*: VkStructureType | |
| 5662 pNext*: pointer | |
| 5663 flags*: VkSemaphoreCreateFlags | |
| 5664 VkQueryPoolCreateInfo* = object | |
| 5665 sType*: VkStructureType | |
| 5666 pNext*: pointer | |
| 5667 flags*: VkQueryPoolCreateFlags | |
| 5668 queryType*: VkQueryType | |
| 5669 queryCount*: uint32 | |
| 5670 pipelineStatistics*: VkQueryPipelineStatisticFlags | |
| 5671 VkFramebufferCreateInfo* = object | |
| 5672 sType*: VkStructureType | |
| 5673 pNext*: pointer | |
| 5674 flags*: VkFramebufferCreateFlags | |
| 5675 renderPass*: VkRenderPass | |
| 5676 attachmentCount*: uint32 | |
| 5677 pAttachments*: ptr VkImageView | |
| 5678 width*: uint32 | |
| 5679 height*: uint32 | |
| 5680 layers*: uint32 | |
| 5681 VkDrawIndirectCommand* = object | |
| 5682 vertexCount*: uint32 | |
| 5683 instanceCount*: uint32 | |
| 5684 firstVertex*: uint32 | |
| 5685 firstInstance*: uint32 | |
| 5686 VkDrawIndexedIndirectCommand* = object | |
| 5687 indexCount*: uint32 | |
| 5688 instanceCount*: uint32 | |
| 5689 firstIndex*: uint32 | |
| 5690 vertexOffset*: int32 | |
| 5691 firstInstance*: uint32 | |
| 5692 VkDispatchIndirectCommand* = object | |
| 5693 x*: uint32 | |
| 5694 y*: uint32 | |
| 5695 z*: uint32 | |
| 5696 VkMultiDrawInfoEXT* = object | |
| 5697 firstVertex*: uint32 | |
| 5698 vertexCount*: uint32 | |
| 5699 VkMultiDrawIndexedInfoEXT* = object | |
| 5700 firstIndex*: uint32 | |
| 5701 indexCount*: uint32 | |
| 5702 vertexOffset*: int32 | |
| 5703 VkSubmitInfo* = object | |
| 5704 sType*: VkStructureType | |
| 5705 pNext*: pointer | |
| 5706 waitSemaphoreCount*: uint32 | |
| 5707 pWaitSemaphores*: ptr VkSemaphore | |
| 5708 pWaitDstStageMask*: ptr VkPipelineStageFlags | |
| 5709 commandBufferCount*: uint32 | |
| 5710 pCommandBuffers*: ptr VkCommandBuffer | |
| 5711 signalSemaphoreCount*: uint32 | |
| 5712 pSignalSemaphores*: ptr VkSemaphore | |
| 5713 VkDisplayPropertiesKHR* = object | |
| 5714 display*: VkDisplayKHR | |
| 5715 displayName*: cstring | |
| 5716 physicalDimensions*: VkExtent2D | |
| 5717 physicalResolution*: VkExtent2D | |
| 5718 supportedTransforms*: VkSurfaceTransformFlagsKHR | |
| 5719 planeReorderPossible*: VkBool32 | |
| 5720 persistentContent*: VkBool32 | |
| 5721 VkDisplayPlanePropertiesKHR* = object | |
| 5722 currentDisplay*: VkDisplayKHR | |
| 5723 currentStackIndex*: uint32 | |
| 5724 VkDisplayModeParametersKHR* = object | |
| 5725 visibleRegion*: VkExtent2D | |
| 5726 refreshRate*: uint32 | |
| 5727 VkDisplayModePropertiesKHR* = object | |
| 5728 displayMode*: VkDisplayModeKHR | |
| 5729 parameters*: VkDisplayModeParametersKHR | |
| 5730 VkDisplayModeCreateInfoKHR* = object | |
| 5731 sType*: VkStructureType | |
| 5732 pNext*: pointer | |
| 5733 flags*: VkDisplayModeCreateFlagsKHR | |
| 5734 parameters*: VkDisplayModeParametersKHR | |
| 5735 VkDisplayPlaneCapabilitiesKHR* = object | |
| 5736 supportedAlpha*: VkDisplayPlaneAlphaFlagsKHR | |
| 5737 minSrcPosition*: VkOffset2D | |
| 5738 maxSrcPosition*: VkOffset2D | |
| 5739 minSrcExtent*: VkExtent2D | |
| 5740 maxSrcExtent*: VkExtent2D | |
| 5741 minDstPosition*: VkOffset2D | |
| 5742 maxDstPosition*: VkOffset2D | |
| 5743 minDstExtent*: VkExtent2D | |
| 5744 maxDstExtent*: VkExtent2D | |
| 5745 VkDisplaySurfaceCreateInfoKHR* = object | |
| 5746 sType*: VkStructureType | |
| 5747 pNext*: pointer | |
| 5748 flags*: VkDisplaySurfaceCreateFlagsKHR | |
| 5749 displayMode*: VkDisplayModeKHR | |
| 5750 planeIndex*: uint32 | |
| 5751 planeStackIndex*: uint32 | |
| 5752 transform*: VkSurfaceTransformFlagBitsKHR | |
| 5753 globalAlpha*: float32 | |
| 5754 alphaMode*: VkDisplayPlaneAlphaFlagBitsKHR | |
| 5755 imageExtent*: VkExtent2D | |
| 5756 VkDisplayPresentInfoKHR* = object | |
| 5757 sType*: VkStructureType | |
| 5758 pNext*: pointer | |
| 5759 srcRect*: VkRect2D | |
| 5760 dstRect*: VkRect2D | |
| 5761 persistent*: VkBool32 | |
| 5762 VkSurfaceCapabilitiesKHR* = object | |
| 5763 minImageCount*: uint32 | |
| 5764 maxImageCount*: uint32 | |
| 5765 currentExtent*: VkExtent2D | |
| 5766 minImageExtent*: VkExtent2D | |
| 5767 maxImageExtent*: VkExtent2D | |
| 5768 maxImageArrayLayers*: uint32 | |
| 5769 supportedTransforms*: VkSurfaceTransformFlagsKHR | |
| 5770 currentTransform*: VkSurfaceTransformFlagBitsKHR | |
| 5771 supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR | |
| 5772 supportedUsageFlags*: VkImageUsageFlags | |
| 5773 VkSurfaceFormatKHR* = object | |
| 5774 format*: VkFormat | |
| 5775 colorSpace*: VkColorSpaceKHR | |
| 5776 VkSwapchainCreateInfoKHR* = object | |
| 5777 sType*: VkStructureType | |
| 5778 pNext*: pointer | |
| 5779 flags*: VkSwapchainCreateFlagsKHR | |
| 5780 surface*: VkSurfaceKHR | |
| 5781 minImageCount*: uint32 | |
| 5782 imageFormat*: VkFormat | |
| 5783 imageColorSpace*: VkColorSpaceKHR | |
| 5784 imageExtent*: VkExtent2D | |
| 5785 imageArrayLayers*: uint32 | |
| 5786 imageUsage*: VkImageUsageFlags | |
| 5787 imageSharingMode*: VkSharingMode | |
| 5788 queueFamilyIndexCount*: uint32 | |
| 5789 pQueueFamilyIndices*: ptr uint32 | |
| 5790 preTransform*: VkSurfaceTransformFlagBitsKHR | |
| 5791 compositeAlpha*: VkCompositeAlphaFlagBitsKHR | |
| 5792 presentMode*: VkPresentModeKHR | |
| 5793 clipped*: VkBool32 | |
| 5794 oldSwapchain*: VkSwapchainKHR | |
| 5795 VkPresentInfoKHR* = object | |
| 5796 sType*: VkStructureType | |
| 5797 pNext*: pointer | |
| 5798 waitSemaphoreCount*: uint32 | |
| 5799 pWaitSemaphores*: ptr VkSemaphore | |
| 5800 swapchainCount*: uint32 | |
| 5801 pSwapchains*: ptr VkSwapchainKHR | |
| 5802 pImageIndices*: ptr uint32 | |
| 5803 pResults*: ptr VkResult | |
| 5804 VkDebugReportCallbackCreateInfoEXT* = object | |
| 5805 sType*: VkStructureType | |
| 5806 pNext*: pointer | |
| 5807 flags*: VkDebugReportFlagsEXT | |
| 5808 pfnCallback*: PFN_vkDebugReportCallbackEXT | |
| 5809 pUserData*: pointer | |
| 5810 VkValidationFlagsEXT* = object | |
| 5811 sType*: VkStructureType | |
| 5812 pNext*: pointer | |
| 5813 disabledValidationCheckCount*: uint32 | |
| 5814 pDisabledValidationChecks*: ptr VkValidationCheckEXT | |
| 5815 VkValidationFeaturesEXT* = object | |
| 5816 sType*: VkStructureType | |
| 5817 pNext*: pointer | |
| 5818 enabledValidationFeatureCount*: uint32 | |
| 5819 pEnabledValidationFeatures*: ptr VkValidationFeatureEnableEXT | |
| 5820 disabledValidationFeatureCount*: uint32 | |
| 5821 pDisabledValidationFeatures*: ptr VkValidationFeatureDisableEXT | |
| 5822 VkApplicationParametersEXT* = object | |
| 5823 sType*: VkStructureType | |
| 5824 pNext*: pointer | |
| 5825 vendorID*: uint32 | |
| 5826 deviceID*: uint32 | |
| 5827 key*: uint32 | |
| 5828 value*: uint64 | |
| 5829 VkPipelineRasterizationStateRasterizationOrderAMD* = object | |
| 5830 sType*: VkStructureType | |
| 5831 pNext*: pointer | |
| 5832 rasterizationOrder*: VkRasterizationOrderAMD | |
| 5833 VkDebugMarkerObjectNameInfoEXT* = object | |
| 5834 sType*: VkStructureType | |
| 5835 pNext*: pointer | |
| 5836 objectType*: VkDebugReportObjectTypeEXT | |
| 5837 theobject*: uint64 | |
| 5838 pObjectName*: cstring | |
| 5839 VkDebugMarkerObjectTagInfoEXT* = object | |
| 5840 sType*: VkStructureType | |
| 5841 pNext*: pointer | |
| 5842 objectType*: VkDebugReportObjectTypeEXT | |
| 5843 theobject*: uint64 | |
| 5844 tagName*: uint64 | |
| 5845 tagSize*: csize_t | |
| 5846 pTag*: pointer | |
| 5847 VkDebugMarkerMarkerInfoEXT* = object | |
| 5848 sType*: VkStructureType | |
| 5849 pNext*: pointer | |
| 5850 pMarkerName*: cstring | |
| 5851 color*: array[4, float32] | |
| 5852 VkDedicatedAllocationImageCreateInfoNV* = object | |
| 5853 sType*: VkStructureType | |
| 5854 pNext*: pointer | |
| 5855 dedicatedAllocation*: VkBool32 | |
| 5856 VkDedicatedAllocationBufferCreateInfoNV* = object | |
| 5857 sType*: VkStructureType | |
| 5858 pNext*: pointer | |
| 5859 dedicatedAllocation*: VkBool32 | |
| 5860 VkDedicatedAllocationMemoryAllocateInfoNV* = object | |
| 5861 sType*: VkStructureType | |
| 5862 pNext*: pointer | |
| 5863 image*: VkImage | |
| 5864 buffer*: VkBuffer | |
| 5865 VkExternalImageFormatPropertiesNV* = object | |
| 5866 imageFormatProperties*: VkImageFormatProperties | |
| 5867 externalMemoryFeatures*: VkExternalMemoryFeatureFlagsNV | |
| 5868 exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlagsNV | |
| 5869 compatibleHandleTypes*: VkExternalMemoryHandleTypeFlagsNV | |
| 5870 VkExternalMemoryImageCreateInfoNV* = object | |
| 5871 sType*: VkStructureType | |
| 5872 pNext*: pointer | |
| 5873 handleTypes*: VkExternalMemoryHandleTypeFlagsNV | |
| 5874 VkExportMemoryAllocateInfoNV* = object | |
| 5875 sType*: VkStructureType | |
| 5876 pNext*: pointer | |
| 5877 handleTypes*: VkExternalMemoryHandleTypeFlagsNV | |
| 5878 VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* = object | |
| 5879 sType*: VkStructureType | |
| 5880 pNext*: pointer | |
| 5881 deviceGeneratedCommands*: VkBool32 | |
| 5882 VkDevicePrivateDataCreateInfo* = object | |
| 5883 sType*: VkStructureType | |
| 5884 pNext*: pointer | |
| 5885 privateDataSlotRequestCount*: uint32 | |
| 5886 VkDevicePrivateDataCreateInfoEXT* = object | |
| 5887 VkPrivateDataSlotCreateInfo* = object | |
| 5888 sType*: VkStructureType | |
| 5889 pNext*: pointer | |
| 5890 flags*: VkPrivateDataSlotCreateFlags | |
| 5891 VkPrivateDataSlotCreateInfoEXT* = object | |
| 5892 VkPhysicalDevicePrivateDataFeatures* = object | |
| 5893 sType*: VkStructureType | |
| 5894 pNext*: pointer | |
| 5895 privateData*: VkBool32 | |
| 5896 VkPhysicalDevicePrivateDataFeaturesEXT* = object | |
| 5897 VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* = object | |
| 5898 sType*: VkStructureType | |
| 5899 pNext*: pointer | |
| 5900 maxGraphicsShaderGroupCount*: uint32 | |
| 5901 maxIndirectSequenceCount*: uint32 | |
| 5902 maxIndirectCommandsTokenCount*: uint32 | |
| 5903 maxIndirectCommandsStreamCount*: uint32 | |
| 5904 maxIndirectCommandsTokenOffset*: uint32 | |
| 5905 maxIndirectCommandsStreamStride*: uint32 | |
| 5906 minSequencesCountBufferOffsetAlignment*: uint32 | |
| 5907 minSequencesIndexBufferOffsetAlignment*: uint32 | |
| 5908 minIndirectCommandsBufferOffsetAlignment*: uint32 | |
| 5909 VkPhysicalDeviceMultiDrawPropertiesEXT* = object | |
| 5910 sType*: VkStructureType | |
| 5911 pNext*: pointer | |
| 5912 maxMultiDrawCount*: uint32 | |
| 5913 VkGraphicsShaderGroupCreateInfoNV* = object | |
| 5914 sType*: VkStructureType | |
| 5915 pNext*: pointer | |
| 5916 stageCount*: uint32 | |
| 5917 pStages*: ptr VkPipelineShaderStageCreateInfo | |
| 5918 pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo | |
| 5919 pTessellationState*: ptr VkPipelineTessellationStateCreateInfo | |
| 5920 VkGraphicsPipelineShaderGroupsCreateInfoNV* = object | |
| 5921 sType*: VkStructureType | |
| 5922 pNext*: pointer | |
| 5923 groupCount*: uint32 | |
| 5924 pGroups*: ptr VkGraphicsShaderGroupCreateInfoNV | |
| 5925 pipelineCount*: uint32 | |
| 5926 pPipelines*: ptr VkPipeline | |
| 5927 VkBindShaderGroupIndirectCommandNV* = object | |
| 5928 groupIndex*: uint32 | |
| 5929 VkBindIndexBufferIndirectCommandNV* = object | |
| 5930 bufferAddress*: VkDeviceAddress | |
| 5931 size*: uint32 | |
| 5932 indexType*: VkIndexType | |
| 5933 VkBindVertexBufferIndirectCommandNV* = object | |
| 5934 bufferAddress*: VkDeviceAddress | |
| 5935 size*: uint32 | |
| 5936 stride*: uint32 | |
| 5937 VkSetStateFlagsIndirectCommandNV* = object | |
| 5938 data*: uint32 | |
| 5939 VkIndirectCommandsStreamNV* = object | |
| 5940 buffer*: VkBuffer | |
| 5941 offset*: VkDeviceSize | |
| 5942 VkIndirectCommandsLayoutTokenNV* = object | |
| 5943 sType*: VkStructureType | |
| 5944 pNext*: pointer | |
| 5945 tokenType*: VkIndirectCommandsTokenTypeNV | |
| 5946 stream*: uint32 | |
| 5947 offset*: uint32 | |
| 5948 vertexBindingUnit*: uint32 | |
| 5949 vertexDynamicStride*: VkBool32 | |
| 5950 pushconstantPipelineLayout*: VkPipelineLayout | |
| 5951 pushconstantShaderStageFlags*: VkShaderStageFlags | |
| 5952 pushconstantOffset*: uint32 | |
| 5953 pushconstantSize*: uint32 | |
| 5954 indirectStateFlags*: VkIndirectStateFlagsNV | |
| 5955 indexTypeCount*: uint32 | |
| 5956 pIndexTypes*: ptr VkIndexType | |
| 5957 pIndexTypeValues*: ptr uint32 | |
| 5958 VkIndirectCommandsLayoutCreateInfoNV* = object | |
| 5959 sType*: VkStructureType | |
| 5960 pNext*: pointer | |
| 5961 flags*: VkIndirectCommandsLayoutUsageFlagsNV | |
| 5962 pipelineBindPoint*: VkPipelineBindPoint | |
| 5963 tokenCount*: uint32 | |
| 5964 pTokens*: ptr VkIndirectCommandsLayoutTokenNV | |
| 5965 streamCount*: uint32 | |
| 5966 pStreamStrides*: ptr uint32 | |
| 5967 VkGeneratedCommandsInfoNV* = object | |
| 5968 sType*: VkStructureType | |
| 5969 pNext*: pointer | |
| 5970 pipelineBindPoint*: VkPipelineBindPoint | |
| 5971 pipeline*: VkPipeline | |
| 5972 indirectCommandsLayout*: VkIndirectCommandsLayoutNV | |
| 5973 streamCount*: uint32 | |
| 5974 pStreams*: ptr VkIndirectCommandsStreamNV | |
| 5975 sequencesCount*: uint32 | |
| 5976 preprocessBuffer*: VkBuffer | |
| 5977 preprocessOffset*: VkDeviceSize | |
| 5978 preprocessSize*: VkDeviceSize | |
| 5979 sequencesCountBuffer*: VkBuffer | |
| 5980 sequencesCountOffset*: VkDeviceSize | |
| 5981 sequencesIndexBuffer*: VkBuffer | |
| 5982 sequencesIndexOffset*: VkDeviceSize | |
| 5983 VkGeneratedCommandsMemoryRequirementsInfoNV* = object | |
| 5984 sType*: VkStructureType | |
| 5985 pNext*: pointer | |
| 5986 pipelineBindPoint*: VkPipelineBindPoint | |
| 5987 pipeline*: VkPipeline | |
| 5988 indirectCommandsLayout*: VkIndirectCommandsLayoutNV | |
| 5989 maxSequencesCount*: uint32 | |
| 5990 VkPhysicalDeviceFeatures2* = object | |
| 5991 sType*: VkStructureType | |
| 5992 pNext*: pointer | |
| 5993 features*: VkPhysicalDeviceFeatures | |
| 5994 VkPhysicalDeviceFeatures2KHR* = object | |
| 5995 VkPhysicalDeviceProperties2* = object | |
| 5996 sType*: VkStructureType | |
| 5997 pNext*: pointer | |
| 5998 properties*: VkPhysicalDeviceProperties | |
| 5999 VkPhysicalDeviceProperties2KHR* = object | |
| 6000 VkFormatProperties2* = object | |
| 6001 sType*: VkStructureType | |
| 6002 pNext*: pointer | |
| 6003 formatProperties*: VkFormatProperties | |
| 6004 VkFormatProperties2KHR* = object | |
| 6005 VkImageFormatProperties2* = object | |
| 6006 sType*: VkStructureType | |
| 6007 pNext*: pointer | |
| 6008 imageFormatProperties*: VkImageFormatProperties | |
| 6009 VkImageFormatProperties2KHR* = object | |
| 6010 VkPhysicalDeviceImageFormatInfo2* = object | |
| 6011 sType*: VkStructureType | |
| 6012 pNext*: pointer | |
| 6013 format*: VkFormat | |
| 6014 thetype*: VkImageType | |
| 6015 tiling*: VkImageTiling | |
| 6016 usage*: VkImageUsageFlags | |
| 6017 flags*: VkImageCreateFlags | |
| 6018 VkPhysicalDeviceImageFormatInfo2KHR* = object | |
| 6019 VkQueueFamilyProperties2* = object | |
| 6020 sType*: VkStructureType | |
| 6021 pNext*: pointer | |
| 6022 queueFamilyProperties*: VkQueueFamilyProperties | |
| 6023 VkQueueFamilyProperties2KHR* = object | |
| 6024 VkPhysicalDeviceMemoryProperties2* = object | |
| 6025 sType*: VkStructureType | |
| 6026 pNext*: pointer | |
| 6027 memoryProperties*: VkPhysicalDeviceMemoryProperties | |
| 6028 VkPhysicalDeviceMemoryProperties2KHR* = object | |
| 6029 VkSparseImageFormatProperties2* = object | |
| 6030 sType*: VkStructureType | |
| 6031 pNext*: pointer | |
| 6032 properties*: VkSparseImageFormatProperties | |
| 6033 VkSparseImageFormatProperties2KHR* = object | |
| 6034 VkPhysicalDeviceSparseImageFormatInfo2* = object | |
| 6035 sType*: VkStructureType | |
| 6036 pNext*: pointer | |
| 6037 format*: VkFormat | |
| 6038 thetype*: VkImageType | |
| 6039 samples*: VkSampleCountFlagBits | |
| 6040 usage*: VkImageUsageFlags | |
| 6041 tiling*: VkImageTiling | |
| 6042 VkPhysicalDeviceSparseImageFormatInfo2KHR* = object | |
| 6043 VkPhysicalDevicePushDescriptorPropertiesKHR* = object | |
| 6044 sType*: VkStructureType | |
| 6045 pNext*: pointer | |
| 6046 maxPushDescriptors*: uint32 | |
| 6047 VkConformanceVersion* = object | |
| 6048 major*: uint8 | |
| 6049 minor*: uint8 | |
| 6050 subminor*: uint8 | |
| 6051 patch*: uint8 | |
| 6052 VkConformanceVersionKHR* = object | |
| 6053 VkPhysicalDeviceDriverProperties* = object | |
| 6054 sType*: VkStructureType | |
| 6055 pNext*: pointer | |
| 6056 driverID*: VkDriverId | |
| 6057 driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char] | |
| 6058 driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char] | |
| 6059 conformanceVersion*: VkConformanceVersion | |
| 6060 VkPhysicalDeviceDriverPropertiesKHR* = object | |
| 6061 VkPresentRegionsKHR* = object | |
| 6062 sType*: VkStructureType | |
| 6063 pNext*: pointer | |
| 6064 swapchainCount*: uint32 | |
| 6065 pRegions*: ptr VkPresentRegionKHR | |
| 6066 VkPresentRegionKHR* = object | |
| 6067 rectangleCount*: uint32 | |
| 6068 pRectangles*: ptr VkRectLayerKHR | |
| 6069 VkRectLayerKHR* = object | |
| 6070 offset*: VkOffset2D | |
| 6071 extent*: VkExtent2D | |
| 6072 layer*: uint32 | |
| 6073 VkPhysicalDeviceVariablePointersFeatures* = object | |
| 6074 sType*: VkStructureType | |
| 6075 pNext*: pointer | |
| 6076 variablePointersStorageBuffer*: VkBool32 | |
| 6077 variablePointers*: VkBool32 | |
| 6078 VkPhysicalDeviceVariablePointersFeaturesKHR* = object | |
| 6079 VkPhysicalDeviceVariablePointerFeaturesKHR* = object | |
| 6080 VkPhysicalDeviceVariablePointerFeatures* = object | |
| 6081 VkExternalMemoryProperties* = object | |
| 6082 externalMemoryFeatures*: VkExternalMemoryFeatureFlags | |
| 6083 exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlags | |
| 6084 compatibleHandleTypes*: VkExternalMemoryHandleTypeFlags | |
| 6085 VkExternalMemoryPropertiesKHR* = object | |
| 6086 VkPhysicalDeviceExternalImageFormatInfo* = object | |
| 6087 sType*: VkStructureType | |
| 6088 pNext*: pointer | |
| 6089 handleType*: VkExternalMemoryHandleTypeFlagBits | |
| 6090 VkPhysicalDeviceExternalImageFormatInfoKHR* = object | |
| 6091 VkExternalImageFormatProperties* = object | |
| 6092 sType*: VkStructureType | |
| 6093 pNext*: pointer | |
| 6094 externalMemoryProperties*: VkExternalMemoryProperties | |
| 6095 VkExternalImageFormatPropertiesKHR* = object | |
| 6096 VkPhysicalDeviceExternalBufferInfo* = object | |
| 6097 sType*: VkStructureType | |
| 6098 pNext*: pointer | |
| 6099 flags*: VkBufferCreateFlags | |
| 6100 usage*: VkBufferUsageFlags | |
| 6101 handleType*: VkExternalMemoryHandleTypeFlagBits | |
| 6102 VkPhysicalDeviceExternalBufferInfoKHR* = object | |
| 6103 VkExternalBufferProperties* = object | |
| 6104 sType*: VkStructureType | |
| 6105 pNext*: pointer | |
| 6106 externalMemoryProperties*: VkExternalMemoryProperties | |
| 6107 VkExternalBufferPropertiesKHR* = object | |
| 6108 VkPhysicalDeviceIDProperties* = object | |
| 6109 sType*: VkStructureType | |
| 6110 pNext*: pointer | |
| 6111 deviceUUID*: array[VK_UUID_SIZE, uint8] | |
| 6112 driverUUID*: array[VK_UUID_SIZE, uint8] | |
| 6113 deviceLUID*: array[VK_LUID_SIZE, uint8] | |
| 6114 deviceNodeMask*: uint32 | |
| 6115 deviceLUIDValid*: VkBool32 | |
| 6116 VkPhysicalDeviceIDPropertiesKHR* = object | |
| 6117 VkExternalMemoryImageCreateInfo* = object | |
| 6118 sType*: VkStructureType | |
| 6119 pNext*: pointer | |
| 6120 handleTypes*: VkExternalMemoryHandleTypeFlags | |
| 6121 VkExternalMemoryImageCreateInfoKHR* = object | |
| 6122 VkExternalMemoryBufferCreateInfo* = object | |
| 6123 sType*: VkStructureType | |
| 6124 pNext*: pointer | |
| 6125 handleTypes*: VkExternalMemoryHandleTypeFlags | |
| 6126 VkExternalMemoryBufferCreateInfoKHR* = object | |
| 6127 VkExportMemoryAllocateInfo* = object | |
| 6128 sType*: VkStructureType | |
| 6129 pNext*: pointer | |
| 6130 handleTypes*: VkExternalMemoryHandleTypeFlags | |
| 6131 VkExportMemoryAllocateInfoKHR* = object | |
| 6132 VkImportMemoryFdInfoKHR* = object | |
| 6133 sType*: VkStructureType | |
| 6134 pNext*: pointer | |
| 6135 handleType*: VkExternalMemoryHandleTypeFlagBits | |
| 6136 fd*: cint | |
| 6137 VkMemoryFdPropertiesKHR* = object | |
| 6138 sType*: VkStructureType | |
| 6139 pNext*: pointer | |
| 6140 memoryTypeBits*: uint32 | |
| 6141 VkMemoryGetFdInfoKHR* = object | |
| 6142 sType*: VkStructureType | |
| 6143 pNext*: pointer | |
| 6144 memory*: VkDeviceMemory | |
| 6145 handleType*: VkExternalMemoryHandleTypeFlagBits | |
| 6146 VkPhysicalDeviceExternalSemaphoreInfo* = object | |
| 6147 sType*: VkStructureType | |
| 6148 pNext*: pointer | |
| 6149 handleType*: VkExternalSemaphoreHandleTypeFlagBits | |
| 6150 VkPhysicalDeviceExternalSemaphoreInfoKHR* = object | |
| 6151 VkExternalSemaphoreProperties* = object | |
| 6152 sType*: VkStructureType | |
| 6153 pNext*: pointer | |
| 6154 exportFromImportedHandleTypes*: VkExternalSemaphoreHandleTypeFlags | |
| 6155 compatibleHandleTypes*: VkExternalSemaphoreHandleTypeFlags | |
| 6156 externalSemaphoreFeatures*: VkExternalSemaphoreFeatureFlags | |
| 6157 VkExternalSemaphorePropertiesKHR* = object | |
| 6158 VkExportSemaphoreCreateInfo* = object | |
| 6159 sType*: VkStructureType | |
| 6160 pNext*: pointer | |
| 6161 handleTypes*: VkExternalSemaphoreHandleTypeFlags | |
| 6162 VkExportSemaphoreCreateInfoKHR* = object | |
| 6163 VkImportSemaphoreFdInfoKHR* = object | |
| 6164 sType*: VkStructureType | |
| 6165 pNext*: pointer | |
| 6166 semaphore*: VkSemaphore | |
| 6167 flags*: VkSemaphoreImportFlags | |
| 6168 handleType*: VkExternalSemaphoreHandleTypeFlagBits | |
| 6169 fd*: cint | |
| 6170 VkSemaphoreGetFdInfoKHR* = object | |
| 6171 sType*: VkStructureType | |
| 6172 pNext*: pointer | |
| 6173 semaphore*: VkSemaphore | |
| 6174 handleType*: VkExternalSemaphoreHandleTypeFlagBits | |
| 6175 VkPhysicalDeviceExternalFenceInfo* = object | |
| 6176 sType*: VkStructureType | |
| 6177 pNext*: pointer | |
| 6178 handleType*: VkExternalFenceHandleTypeFlagBits | |
| 6179 VkPhysicalDeviceExternalFenceInfoKHR* = object | |
| 6180 VkExternalFenceProperties* = object | |
| 6181 sType*: VkStructureType | |
| 6182 pNext*: pointer | |
| 6183 exportFromImportedHandleTypes*: VkExternalFenceHandleTypeFlags | |
| 6184 compatibleHandleTypes*: VkExternalFenceHandleTypeFlags | |
| 6185 externalFenceFeatures*: VkExternalFenceFeatureFlags | |
| 6186 VkExternalFencePropertiesKHR* = object | |
| 6187 VkExportFenceCreateInfo* = object | |
| 6188 sType*: VkStructureType | |
| 6189 pNext*: pointer | |
| 6190 handleTypes*: VkExternalFenceHandleTypeFlags | |
| 6191 VkExportFenceCreateInfoKHR* = object | |
| 6192 VkImportFenceFdInfoKHR* = object | |
| 6193 sType*: VkStructureType | |
| 6194 pNext*: pointer | |
| 6195 fence*: VkFence | |
| 6196 flags*: VkFenceImportFlags | |
| 6197 handleType*: VkExternalFenceHandleTypeFlagBits | |
| 6198 fd*: cint | |
| 6199 VkFenceGetFdInfoKHR* = object | |
| 6200 sType*: VkStructureType | |
| 6201 pNext*: pointer | |
| 6202 fence*: VkFence | |
| 6203 handleType*: VkExternalFenceHandleTypeFlagBits | |
| 6204 VkPhysicalDeviceMultiviewFeatures* = object | |
| 6205 sType*: VkStructureType | |
| 6206 pNext*: pointer | |
| 6207 multiview*: VkBool32 | |
| 6208 multiviewGeometryShader*: VkBool32 | |
| 6209 multiviewTessellationShader*: VkBool32 | |
| 6210 VkPhysicalDeviceMultiviewFeaturesKHR* = object | |
| 6211 VkPhysicalDeviceMultiviewProperties* = object | |
| 6212 sType*: VkStructureType | |
| 6213 pNext*: pointer | |
| 6214 maxMultiviewViewCount*: uint32 | |
| 6215 maxMultiviewInstanceIndex*: uint32 | |
| 6216 VkPhysicalDeviceMultiviewPropertiesKHR* = object | |
| 6217 VkRenderPassMultiviewCreateInfo* = object | |
| 6218 sType*: VkStructureType | |
| 6219 pNext*: pointer | |
| 6220 subpassCount*: uint32 | |
| 6221 pViewMasks*: ptr uint32 | |
| 6222 dependencyCount*: uint32 | |
| 6223 pViewOffsets*: ptr int32 | |
| 6224 correlationMaskCount*: uint32 | |
| 6225 pCorrelationMasks*: ptr uint32 | |
| 6226 VkRenderPassMultiviewCreateInfoKHR* = object | |
| 6227 VkSurfaceCapabilities2EXT* = object | |
| 6228 sType*: VkStructureType | |
| 6229 pNext*: pointer | |
| 6230 minImageCount*: uint32 | |
| 6231 maxImageCount*: uint32 | |
| 6232 currentExtent*: VkExtent2D | |
| 6233 minImageExtent*: VkExtent2D | |
| 6234 maxImageExtent*: VkExtent2D | |
| 6235 maxImageArrayLayers*: uint32 | |
| 6236 supportedTransforms*: VkSurfaceTransformFlagsKHR | |
| 6237 currentTransform*: VkSurfaceTransformFlagBitsKHR | |
| 6238 supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR | |
| 6239 supportedUsageFlags*: VkImageUsageFlags | |
| 6240 supportedSurfaceCounters*: VkSurfaceCounterFlagsEXT | |
| 6241 VkDisplayPowerInfoEXT* = object | |
| 6242 sType*: VkStructureType | |
| 6243 pNext*: pointer | |
| 6244 powerState*: VkDisplayPowerStateEXT | |
| 6245 VkDeviceEventInfoEXT* = object | |
| 6246 sType*: VkStructureType | |
| 6247 pNext*: pointer | |
| 6248 deviceEvent*: VkDeviceEventTypeEXT | |
| 6249 VkDisplayEventInfoEXT* = object | |
| 6250 sType*: VkStructureType | |
| 6251 pNext*: pointer | |
| 6252 displayEvent*: VkDisplayEventTypeEXT | |
| 6253 VkSwapchainCounterCreateInfoEXT* = object | |
| 6254 sType*: VkStructureType | |
| 6255 pNext*: pointer | |
| 6256 surfaceCounters*: VkSurfaceCounterFlagsEXT | |
| 6257 VkPhysicalDeviceGroupProperties* = object | |
| 6258 sType*: VkStructureType | |
| 6259 pNext*: pointer | |
| 6260 physicalDeviceCount*: uint32 | |
| 6261 physicalDevices*: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice] | |
| 6262 subsetAllocation*: VkBool32 | |
| 6263 VkPhysicalDeviceGroupPropertiesKHR* = object | |
| 6264 VkMemoryAllocateFlagsInfo* = object | |
| 6265 sType*: VkStructureType | |
| 6266 pNext*: pointer | |
| 6267 flags*: VkMemoryAllocateFlags | |
| 6268 deviceMask*: uint32 | |
| 6269 VkMemoryAllocateFlagsInfoKHR* = object | |
| 6270 VkBindBufferMemoryInfo* = object | |
| 6271 sType*: VkStructureType | |
| 6272 pNext*: pointer | |
| 6273 buffer*: VkBuffer | |
| 6274 memory*: VkDeviceMemory | |
| 6275 memoryOffset*: VkDeviceSize | |
| 6276 VkBindBufferMemoryInfoKHR* = object | |
| 6277 VkBindBufferMemoryDeviceGroupInfo* = object | |
| 6278 sType*: VkStructureType | |
| 6279 pNext*: pointer | |
| 6280 deviceIndexCount*: uint32 | |
| 6281 pDeviceIndices*: ptr uint32 | |
| 6282 VkBindBufferMemoryDeviceGroupInfoKHR* = object | |
| 6283 VkBindImageMemoryInfo* = object | |
| 6284 sType*: VkStructureType | |
| 6285 pNext*: pointer | |
| 6286 image*: VkImage | |
| 6287 memory*: VkDeviceMemory | |
| 6288 memoryOffset*: VkDeviceSize | |
| 6289 VkBindImageMemoryInfoKHR* = object | |
| 6290 VkBindImageMemoryDeviceGroupInfo* = object | |
| 6291 sType*: VkStructureType | |
| 6292 pNext*: pointer | |
| 6293 deviceIndexCount*: uint32 | |
| 6294 pDeviceIndices*: ptr uint32 | |
| 6295 splitInstanceBindRegionCount*: uint32 | |
| 6296 pSplitInstanceBindRegions*: ptr VkRect2D | |
| 6297 VkBindImageMemoryDeviceGroupInfoKHR* = object | |
| 6298 VkDeviceGroupRenderPassBeginInfo* = object | |
| 6299 sType*: VkStructureType | |
| 6300 pNext*: pointer | |
| 6301 deviceMask*: uint32 | |
| 6302 deviceRenderAreaCount*: uint32 | |
| 6303 pDeviceRenderAreas*: ptr VkRect2D | |
| 6304 VkDeviceGroupRenderPassBeginInfoKHR* = object | |
| 6305 VkDeviceGroupCommandBufferBeginInfo* = object | |
| 6306 sType*: VkStructureType | |
| 6307 pNext*: pointer | |
| 6308 deviceMask*: uint32 | |
| 6309 VkDeviceGroupCommandBufferBeginInfoKHR* = object | |
| 6310 VkDeviceGroupSubmitInfo* = object | |
| 6311 sType*: VkStructureType | |
| 6312 pNext*: pointer | |
| 6313 waitSemaphoreCount*: uint32 | |
| 6314 pWaitSemaphoreDeviceIndices*: ptr uint32 | |
| 6315 commandBufferCount*: uint32 | |
| 6316 pCommandBufferDeviceMasks*: ptr uint32 | |
| 6317 signalSemaphoreCount*: uint32 | |
| 6318 pSignalSemaphoreDeviceIndices*: ptr uint32 | |
| 6319 VkDeviceGroupSubmitInfoKHR* = object | |
| 6320 VkDeviceGroupBindSparseInfo* = object | |
| 6321 sType*: VkStructureType | |
| 6322 pNext*: pointer | |
| 6323 resourceDeviceIndex*: uint32 | |
| 6324 memoryDeviceIndex*: uint32 | |
| 6325 VkDeviceGroupBindSparseInfoKHR* = object | |
| 6326 VkDeviceGroupPresentCapabilitiesKHR* = object | |
| 6327 sType*: VkStructureType | |
| 6328 pNext*: pointer | |
| 6329 presentMask*: array[VK_MAX_DEVICE_GROUP_SIZE, uint32] | |
| 6330 modes*: VkDeviceGroupPresentModeFlagsKHR | |
| 6331 VkImageSwapchainCreateInfoKHR* = object | |
| 6332 sType*: VkStructureType | |
| 6333 pNext*: pointer | |
| 6334 swapchain*: VkSwapchainKHR | |
| 6335 VkBindImageMemorySwapchainInfoKHR* = object | |
| 6336 sType*: VkStructureType | |
| 6337 pNext*: pointer | |
| 6338 swapchain*: VkSwapchainKHR | |
| 6339 imageIndex*: uint32 | |
| 6340 VkAcquireNextImageInfoKHR* = object | |
| 6341 sType*: VkStructureType | |
| 6342 pNext*: pointer | |
| 6343 swapchain*: VkSwapchainKHR | |
| 6344 timeout*: uint64 | |
| 6345 semaphore*: VkSemaphore | |
| 6346 fence*: VkFence | |
| 6347 deviceMask*: uint32 | |
| 6348 VkDeviceGroupPresentInfoKHR* = object | |
| 6349 sType*: VkStructureType | |
| 6350 pNext*: pointer | |
| 6351 swapchainCount*: uint32 | |
| 6352 pDeviceMasks*: ptr uint32 | |
| 6353 mode*: VkDeviceGroupPresentModeFlagBitsKHR | |
| 6354 VkDeviceGroupDeviceCreateInfo* = object | |
| 6355 sType*: VkStructureType | |
| 6356 pNext*: pointer | |
| 6357 physicalDeviceCount*: uint32 | |
| 6358 pPhysicalDevices*: ptr VkPhysicalDevice | |
| 6359 VkDeviceGroupDeviceCreateInfoKHR* = object | |
| 6360 VkDeviceGroupSwapchainCreateInfoKHR* = object | |
| 6361 sType*: VkStructureType | |
| 6362 pNext*: pointer | |
| 6363 modes*: VkDeviceGroupPresentModeFlagsKHR | |
| 6364 VkDescriptorUpdateTemplateEntry* = object | |
| 6365 dstBinding*: uint32 | |
| 6366 dstArrayElement*: uint32 | |
| 6367 descriptorCount*: uint32 | |
| 6368 descriptorType*: VkDescriptorType | |
| 6369 offset*: csize_t | |
| 6370 stride*: csize_t | |
| 6371 VkDescriptorUpdateTemplateEntryKHR* = object | |
| 6372 VkDescriptorUpdateTemplateCreateInfo* = object | |
| 6373 sType*: VkStructureType | |
| 6374 pNext*: pointer | |
| 6375 flags*: VkDescriptorUpdateTemplateCreateFlags | |
| 6376 descriptorUpdateEntryCount*: uint32 | |
| 6377 pDescriptorUpdateEntries*: ptr VkDescriptorUpdateTemplateEntry | |
| 6378 templateType*: VkDescriptorUpdateTemplateType | |
| 6379 descriptorSetLayout*: VkDescriptorSetLayout | |
| 6380 pipelineBindPoint*: VkPipelineBindPoint | |
| 6381 pipelineLayout*: VkPipelineLayout | |
| 6382 set*: uint32 | |
| 6383 VkDescriptorUpdateTemplateCreateInfoKHR* = object | |
| 6384 VkXYColorEXT* = object | |
| 6385 x*: float32 | |
| 6386 y*: float32 | |
| 6387 VkPhysicalDevicePresentIdFeaturesKHR* = object | |
| 6388 sType*: VkStructureType | |
| 6389 pNext*: pointer | |
| 6390 presentId*: VkBool32 | |
| 6391 VkPresentIdKHR* = object | |
| 6392 sType*: VkStructureType | |
| 6393 pNext*: pointer | |
| 6394 swapchainCount*: uint32 | |
| 6395 pPresentIds*: ptr uint64 | |
| 6396 VkPhysicalDevicePresentWaitFeaturesKHR* = object | |
| 6397 sType*: VkStructureType | |
| 6398 pNext*: pointer | |
| 6399 presentWait*: VkBool32 | |
| 6400 VkHdrMetadataEXT* = object | |
| 6401 sType*: VkStructureType | |
| 6402 pNext*: pointer | |
| 6403 displayPrimaryRed*: VkXYColorEXT | |
| 6404 displayPrimaryGreen*: VkXYColorEXT | |
| 6405 displayPrimaryBlue*: VkXYColorEXT | |
| 6406 whitePoint*: VkXYColorEXT | |
| 6407 maxLuminance*: float32 | |
| 6408 minLuminance*: float32 | |
| 6409 maxContentLightLevel*: float32 | |
| 6410 maxFrameAverageLightLevel*: float32 | |
| 6411 VkDisplayNativeHdrSurfaceCapabilitiesAMD* = object | |
| 6412 sType*: VkStructureType | |
| 6413 pNext*: pointer | |
| 6414 localDimmingSupport*: VkBool32 | |
| 6415 VkSwapchainDisplayNativeHdrCreateInfoAMD* = object | |
| 6416 sType*: VkStructureType | |
| 6417 pNext*: pointer | |
| 6418 localDimmingEnable*: VkBool32 | |
| 6419 VkRefreshCycleDurationGOOGLE* = object | |
| 6420 refreshDuration*: uint64 | |
| 6421 VkPastPresentationTimingGOOGLE* = object | |
| 6422 presentID*: uint32 | |
| 6423 desiredPresentTime*: uint64 | |
| 6424 actualPresentTime*: uint64 | |
| 6425 earliestPresentTime*: uint64 | |
| 6426 presentMargin*: uint64 | |
| 6427 VkPresentTimesInfoGOOGLE* = object | |
| 6428 sType*: VkStructureType | |
| 6429 pNext*: pointer | |
| 6430 swapchainCount*: uint32 | |
| 6431 pTimes*: ptr VkPresentTimeGOOGLE | |
| 6432 VkPresentTimeGOOGLE* = object | |
| 6433 presentID*: uint32 | |
| 6434 desiredPresentTime*: uint64 | |
| 6435 VkViewportWScalingNV* = object | |
| 6436 xcoeff*: float32 | |
| 6437 ycoeff*: float32 | |
| 6438 VkPipelineViewportWScalingStateCreateInfoNV* = object | |
| 6439 sType*: VkStructureType | |
| 6440 pNext*: pointer | |
| 6441 viewportWScalingEnable*: VkBool32 | |
| 6442 viewportCount*: uint32 | |
| 6443 pViewportWScalings*: ptr VkViewportWScalingNV | |
| 6444 VkViewportSwizzleNV* = object | |
| 6445 x*: VkViewportCoordinateSwizzleNV | |
| 6446 y*: VkViewportCoordinateSwizzleNV | |
| 6447 z*: VkViewportCoordinateSwizzleNV | |
| 6448 w*: VkViewportCoordinateSwizzleNV | |
| 6449 VkPipelineViewportSwizzleStateCreateInfoNV* = object | |
| 6450 sType*: VkStructureType | |
| 6451 pNext*: pointer | |
| 6452 flags*: VkPipelineViewportSwizzleStateCreateFlagsNV | |
| 6453 viewportCount*: uint32 | |
| 6454 pViewportSwizzles*: ptr VkViewportSwizzleNV | |
| 6455 VkPhysicalDeviceDiscardRectanglePropertiesEXT* = object | |
| 6456 sType*: VkStructureType | |
| 6457 pNext*: pointer | |
| 6458 maxDiscardRectangles*: uint32 | |
| 6459 VkPipelineDiscardRectangleStateCreateInfoEXT* = object | |
| 6460 sType*: VkStructureType | |
| 6461 pNext*: pointer | |
| 6462 flags*: VkPipelineDiscardRectangleStateCreateFlagsEXT | |
| 6463 discardRectangleMode*: VkDiscardRectangleModeEXT | |
| 6464 discardRectangleCount*: uint32 | |
| 6465 pDiscardRectangles*: ptr VkRect2D | |
| 6466 VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* = object | |
| 6467 sType*: VkStructureType | |
| 6468 pNext*: pointer | |
| 6469 perViewPositionAllComponents*: VkBool32 | |
| 6470 VkInputAttachmentAspectReference* = object | |
| 6471 subpass*: uint32 | |
| 6472 inputAttachmentIndex*: uint32 | |
| 6473 aspectMask*: VkImageAspectFlags | |
| 6474 VkInputAttachmentAspectReferenceKHR* = object | |
| 6475 VkRenderPassInputAttachmentAspectCreateInfo* = object | |
| 6476 sType*: VkStructureType | |
| 6477 pNext*: pointer | |
| 6478 aspectReferenceCount*: uint32 | |
| 6479 pAspectReferences*: ptr VkInputAttachmentAspectReference | |
| 6480 VkRenderPassInputAttachmentAspectCreateInfoKHR* = object | |
| 6481 VkPhysicalDeviceSurfaceInfo2KHR* = object | |
| 6482 sType*: VkStructureType | |
| 6483 pNext*: pointer | |
| 6484 surface*: VkSurfaceKHR | |
| 6485 VkSurfaceCapabilities2KHR* = object | |
| 6486 sType*: VkStructureType | |
| 6487 pNext*: pointer | |
| 6488 surfaceCapabilities*: VkSurfaceCapabilitiesKHR | |
| 6489 VkSurfaceFormat2KHR* = object | |
| 6490 sType*: VkStructureType | |
| 6491 pNext*: pointer | |
| 6492 surfaceFormat*: VkSurfaceFormatKHR | |
| 6493 VkDisplayProperties2KHR* = object | |
| 6494 sType*: VkStructureType | |
| 6495 pNext*: pointer | |
| 6496 displayProperties*: VkDisplayPropertiesKHR | |
| 6497 VkDisplayPlaneProperties2KHR* = object | |
| 6498 sType*: VkStructureType | |
| 6499 pNext*: pointer | |
| 6500 displayPlaneProperties*: VkDisplayPlanePropertiesKHR | |
| 6501 VkDisplayModeProperties2KHR* = object | |
| 6502 sType*: VkStructureType | |
| 6503 pNext*: pointer | |
| 6504 displayModeProperties*: VkDisplayModePropertiesKHR | |
| 6505 VkDisplayPlaneInfo2KHR* = object | |
| 6506 sType*: VkStructureType | |
| 6507 pNext*: pointer | |
| 6508 mode*: VkDisplayModeKHR | |
| 6509 planeIndex*: uint32 | |
| 6510 VkDisplayPlaneCapabilities2KHR* = object | |
| 6511 sType*: VkStructureType | |
| 6512 pNext*: pointer | |
| 6513 capabilities*: VkDisplayPlaneCapabilitiesKHR | |
| 6514 VkSharedPresentSurfaceCapabilitiesKHR* = object | |
| 6515 sType*: VkStructureType | |
| 6516 pNext*: pointer | |
| 6517 sharedPresentSupportedUsageFlags*: VkImageUsageFlags | |
| 6518 VkPhysicalDevice16BitStorageFeatures* = object | |
| 6519 sType*: VkStructureType | |
| 6520 pNext*: pointer | |
| 6521 storageBuffer16BitAccess*: VkBool32 | |
| 6522 uniformAndStorageBuffer16BitAccess*: VkBool32 | |
| 6523 storagePushConstant16*: VkBool32 | |
| 6524 storageInputOutput16*: VkBool32 | |
| 6525 VkPhysicalDevice16BitStorageFeaturesKHR* = object | |
| 6526 VkPhysicalDeviceSubgroupProperties* = object | |
| 6527 sType*: VkStructureType | |
| 6528 pNext*: pointer | |
| 6529 subgroupSize*: uint32 | |
| 6530 supportedStages*: VkShaderStageFlags | |
| 6531 supportedOperations*: VkSubgroupFeatureFlags | |
| 6532 quadOperationsInAllStages*: VkBool32 | |
| 6533 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* = object | |
| 6534 sType*: VkStructureType | |
| 6535 pNext*: pointer | |
| 6536 shaderSubgroupExtendedTypes*: VkBool32 | |
| 6537 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR* = object | |
| 6538 VkBufferMemoryRequirementsInfo2* = object | |
| 6539 sType*: VkStructureType | |
| 6540 pNext*: pointer | |
| 6541 buffer*: VkBuffer | |
| 6542 VkBufferMemoryRequirementsInfo2KHR* = object | |
| 6543 VkDeviceBufferMemoryRequirements* = object | |
| 6544 sType*: VkStructureType | |
| 6545 pNext*: pointer | |
| 6546 pCreateInfo*: ptr VkBufferCreateInfo | |
| 6547 VkDeviceBufferMemoryRequirementsKHR* = object | |
| 6548 VkImageMemoryRequirementsInfo2* = object | |
| 6549 sType*: VkStructureType | |
| 6550 pNext*: pointer | |
| 6551 image*: VkImage | |
| 6552 VkImageMemoryRequirementsInfo2KHR* = object | |
| 6553 VkImageSparseMemoryRequirementsInfo2* = object | |
| 6554 sType*: VkStructureType | |
| 6555 pNext*: pointer | |
| 6556 image*: VkImage | |
| 6557 VkImageSparseMemoryRequirementsInfo2KHR* = object | |
| 6558 VkDeviceImageMemoryRequirements* = object | |
| 6559 sType*: VkStructureType | |
| 6560 pNext*: pointer | |
| 6561 pCreateInfo*: ptr VkImageCreateInfo | |
| 6562 planeAspect*: VkImageAspectFlagBits | |
| 6563 VkDeviceImageMemoryRequirementsKHR* = object | |
| 6564 VkMemoryRequirements2* = object | |
| 6565 sType*: VkStructureType | |
| 6566 pNext*: pointer | |
| 6567 memoryRequirements*: VkMemoryRequirements | |
| 6568 VkMemoryRequirements2KHR* = object | |
| 6569 VkSparseImageMemoryRequirements2* = object | |
| 6570 sType*: VkStructureType | |
| 6571 pNext*: pointer | |
| 6572 memoryRequirements*: VkSparseImageMemoryRequirements | |
| 6573 VkSparseImageMemoryRequirements2KHR* = object | |
| 6574 VkPhysicalDevicePointClippingProperties* = object | |
| 6575 sType*: VkStructureType | |
| 6576 pNext*: pointer | |
| 6577 pointClippingBehavior*: VkPointClippingBehavior | |
| 6578 VkPhysicalDevicePointClippingPropertiesKHR* = object | |
| 6579 VkMemoryDedicatedRequirements* = object | |
| 6580 sType*: VkStructureType | |
| 6581 pNext*: pointer | |
| 6582 prefersDedicatedAllocation*: VkBool32 | |
| 6583 requiresDedicatedAllocation*: VkBool32 | |
| 6584 VkMemoryDedicatedRequirementsKHR* = object | |
| 6585 VkMemoryDedicatedAllocateInfo* = object | |
| 6586 sType*: VkStructureType | |
| 6587 pNext*: pointer | |
| 6588 image*: VkImage | |
| 6589 buffer*: VkBuffer | |
| 6590 VkMemoryDedicatedAllocateInfoKHR* = object | |
| 6591 VkImageViewUsageCreateInfo* = object | |
| 6592 sType*: VkStructureType | |
| 6593 pNext*: pointer | |
| 6594 usage*: VkImageUsageFlags | |
| 6595 VkImageViewSlicedCreateInfoEXT* = object | |
| 6596 sType*: VkStructureType | |
| 6597 pNext*: pointer | |
| 6598 sliceOffset*: uint32 | |
| 6599 sliceCount*: uint32 | |
| 6600 VkImageViewUsageCreateInfoKHR* = object | |
| 6601 VkPipelineTessellationDomainOriginStateCreateInfo* = object | |
| 6602 sType*: VkStructureType | |
| 6603 pNext*: pointer | |
| 6604 domainOrigin*: VkTessellationDomainOrigin | |
| 6605 VkPipelineTessellationDomainOriginStateCreateInfoKHR* = object | |
| 6606 VkSamplerYcbcrConversionInfo* = object | |
| 6607 sType*: VkStructureType | |
| 6608 pNext*: pointer | |
| 6609 conversion*: VkSamplerYcbcrConversion | |
| 6610 VkSamplerYcbcrConversionInfoKHR* = object | |
| 6611 VkSamplerYcbcrConversionCreateInfo* = object | |
| 6612 sType*: VkStructureType | |
| 6613 pNext*: pointer | |
| 6614 format*: VkFormat | |
| 6615 ycbcrModel*: VkSamplerYcbcrModelConversion | |
| 6616 ycbcrRange*: VkSamplerYcbcrRange | |
| 6617 components*: VkComponentMapping | |
| 6618 xChromaOffset*: VkChromaLocation | |
| 6619 yChromaOffset*: VkChromaLocation | |
| 6620 chromaFilter*: VkFilter | |
| 6621 forceExplicitReconstruction*: VkBool32 | |
| 6622 VkSamplerYcbcrConversionCreateInfoKHR* = object | |
| 6623 VkBindImagePlaneMemoryInfo* = object | |
| 6624 sType*: VkStructureType | |
| 6625 pNext*: pointer | |
| 6626 planeAspect*: VkImageAspectFlagBits | |
| 6627 VkBindImagePlaneMemoryInfoKHR* = object | |
| 6628 VkImagePlaneMemoryRequirementsInfo* = object | |
| 6629 sType*: VkStructureType | |
| 6630 pNext*: pointer | |
| 6631 planeAspect*: VkImageAspectFlagBits | |
| 6632 VkImagePlaneMemoryRequirementsInfoKHR* = object | |
| 6633 VkPhysicalDeviceSamplerYcbcrConversionFeatures* = object | |
| 6634 sType*: VkStructureType | |
| 6635 pNext*: pointer | |
| 6636 samplerYcbcrConversion*: VkBool32 | |
| 6637 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* = object | |
| 6638 VkSamplerYcbcrConversionImageFormatProperties* = object | |
| 6639 sType*: VkStructureType | |
| 6640 pNext*: pointer | |
| 6641 combinedImageSamplerDescriptorCount*: uint32 | |
| 6642 VkSamplerYcbcrConversionImageFormatPropertiesKHR* = object | |
| 6643 VkTextureLODGatherFormatPropertiesAMD* = object | |
| 6644 sType*: VkStructureType | |
| 6645 pNext*: pointer | |
| 6646 supportsTextureGatherLODBiasAMD*: VkBool32 | |
| 6647 VkConditionalRenderingBeginInfoEXT* = object | |
| 6648 sType*: VkStructureType | |
| 6649 pNext*: pointer | |
| 6650 buffer*: VkBuffer | |
| 6651 offset*: VkDeviceSize | |
| 6652 flags*: VkConditionalRenderingFlagsEXT | |
| 6653 VkProtectedSubmitInfo* = object | |
| 6654 sType*: VkStructureType | |
| 6655 pNext*: pointer | |
| 6656 protectedSubmit*: VkBool32 | |
| 6657 VkPhysicalDeviceProtectedMemoryFeatures* = object | |
| 6658 sType*: VkStructureType | |
| 6659 pNext*: pointer | |
| 6660 protectedMemory*: VkBool32 | |
| 6661 VkPhysicalDeviceProtectedMemoryProperties* = object | |
| 6662 sType*: VkStructureType | |
| 6663 pNext*: pointer | |
| 6664 protectedNoFault*: VkBool32 | |
| 6665 VkDeviceQueueInfo2* = object | |
| 6666 sType*: VkStructureType | |
| 6667 pNext*: pointer | |
| 6668 flags*: VkDeviceQueueCreateFlags | |
| 6669 queueFamilyIndex*: uint32 | |
| 6670 queueIndex*: uint32 | |
| 6671 VkPipelineCoverageToColorStateCreateInfoNV* = object | |
| 6672 sType*: VkStructureType | |
| 6673 pNext*: pointer | |
| 6674 flags*: VkPipelineCoverageToColorStateCreateFlagsNV | |
| 6675 coverageToColorEnable*: VkBool32 | |
| 6676 coverageToColorLocation*: uint32 | |
| 6677 VkPhysicalDeviceSamplerFilterMinmaxProperties* = object | |
| 6678 sType*: VkStructureType | |
| 6679 pNext*: pointer | |
| 6680 filterMinmaxSingleComponentFormats*: VkBool32 | |
| 6681 filterMinmaxImageComponentMapping*: VkBool32 | |
| 6682 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* = object | |
| 6683 VkSampleLocationEXT* = object | |
| 6684 x*: float32 | |
| 6685 y*: float32 | |
| 6686 VkSampleLocationsInfoEXT* = object | |
| 6687 sType*: VkStructureType | |
| 6688 pNext*: pointer | |
| 6689 sampleLocationsPerPixel*: VkSampleCountFlagBits | |
| 6690 sampleLocationGridSize*: VkExtent2D | |
| 6691 sampleLocationsCount*: uint32 | |
| 6692 pSampleLocations*: ptr VkSampleLocationEXT | |
| 6693 VkAttachmentSampleLocationsEXT* = object | |
| 6694 attachmentIndex*: uint32 | |
| 6695 sampleLocationsInfo*: VkSampleLocationsInfoEXT | |
| 6696 VkSubpassSampleLocationsEXT* = object | |
| 6697 subpassIndex*: uint32 | |
| 6698 sampleLocationsInfo*: VkSampleLocationsInfoEXT | |
| 6699 VkRenderPassSampleLocationsBeginInfoEXT* = object | |
| 6700 sType*: VkStructureType | |
| 6701 pNext*: pointer | |
| 6702 attachmentInitialSampleLocationsCount*: uint32 | |
| 6703 pAttachmentInitialSampleLocations*: ptr VkAttachmentSampleLocationsEXT | |
| 6704 postSubpassSampleLocationsCount*: uint32 | |
| 6705 pPostSubpassSampleLocations*: ptr VkSubpassSampleLocationsEXT | |
| 6706 VkPipelineSampleLocationsStateCreateInfoEXT* = object | |
| 6707 sType*: VkStructureType | |
| 6708 pNext*: pointer | |
| 6709 sampleLocationsEnable*: VkBool32 | |
| 6710 sampleLocationsInfo*: VkSampleLocationsInfoEXT | |
| 6711 VkPhysicalDeviceSampleLocationsPropertiesEXT* = object | |
| 6712 sType*: VkStructureType | |
| 6713 pNext*: pointer | |
| 6714 sampleLocationSampleCounts*: VkSampleCountFlags | |
| 6715 maxSampleLocationGridSize*: VkExtent2D | |
| 6716 sampleLocationCoordinateRange*: array[2, float32] | |
| 6717 sampleLocationSubPixelBits*: uint32 | |
| 6718 variableSampleLocations*: VkBool32 | |
| 6719 VkMultisamplePropertiesEXT* = object | |
| 6720 sType*: VkStructureType | |
| 6721 pNext*: pointer | |
| 6722 maxSampleLocationGridSize*: VkExtent2D | |
| 6723 VkSamplerReductionModeCreateInfo* = object | |
| 6724 sType*: VkStructureType | |
| 6725 pNext*: pointer | |
| 6726 reductionMode*: VkSamplerReductionMode | |
| 6727 VkSamplerReductionModeCreateInfoEXT* = object | |
| 6728 VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* = object | |
| 6729 sType*: VkStructureType | |
| 6730 pNext*: pointer | |
| 6731 advancedBlendCoherentOperations*: VkBool32 | |
| 6732 VkPhysicalDeviceMultiDrawFeaturesEXT* = object | |
| 6733 sType*: VkStructureType | |
| 6734 pNext*: pointer | |
| 6735 multiDraw*: VkBool32 | |
| 6736 VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* = object | |
| 6737 sType*: VkStructureType | |
| 6738 pNext*: pointer | |
| 6739 advancedBlendMaxColorAttachments*: uint32 | |
| 6740 advancedBlendIndependentBlend*: VkBool32 | |
| 6741 advancedBlendNonPremultipliedSrcColor*: VkBool32 | |
| 6742 advancedBlendNonPremultipliedDstColor*: VkBool32 | |
| 6743 advancedBlendCorrelatedOverlap*: VkBool32 | |
| 6744 advancedBlendAllOperations*: VkBool32 | |
| 6745 VkPipelineColorBlendAdvancedStateCreateInfoEXT* = object | |
| 6746 sType*: VkStructureType | |
| 6747 pNext*: pointer | |
| 6748 srcPremultiplied*: VkBool32 | |
| 6749 dstPremultiplied*: VkBool32 | |
| 6750 blendOverlap*: VkBlendOverlapEXT | |
| 6751 VkPhysicalDeviceInlineUniformBlockFeatures* = object | |
| 6752 sType*: VkStructureType | |
| 6753 pNext*: pointer | |
| 6754 inlineUniformBlock*: VkBool32 | |
| 6755 descriptorBindingInlineUniformBlockUpdateAfterBind*: VkBool32 | |
| 6756 VkPhysicalDeviceInlineUniformBlockFeaturesEXT* = object | |
| 6757 VkPhysicalDeviceInlineUniformBlockProperties* = object | |
| 6758 sType*: VkStructureType | |
| 6759 pNext*: pointer | |
| 6760 maxInlineUniformBlockSize*: uint32 | |
| 6761 maxPerStageDescriptorInlineUniformBlocks*: uint32 | |
| 6762 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks*: uint32 | |
| 6763 maxDescriptorSetInlineUniformBlocks*: uint32 | |
| 6764 maxDescriptorSetUpdateAfterBindInlineUniformBlocks*: uint32 | |
| 6765 VkPhysicalDeviceInlineUniformBlockPropertiesEXT* = object | |
| 6766 VkWriteDescriptorSetInlineUniformBlock* = object | |
| 6767 sType*: VkStructureType | |
| 6768 pNext*: pointer | |
| 6769 dataSize*: uint32 | |
| 6770 pData*: pointer | |
| 6771 VkWriteDescriptorSetInlineUniformBlockEXT* = object | |
| 6772 VkDescriptorPoolInlineUniformBlockCreateInfo* = object | |
| 6773 sType*: VkStructureType | |
| 6774 pNext*: pointer | |
| 6775 maxInlineUniformBlockBindings*: uint32 | |
| 6776 VkDescriptorPoolInlineUniformBlockCreateInfoEXT* = object | |
| 6777 VkPipelineCoverageModulationStateCreateInfoNV* = object | |
| 6778 sType*: VkStructureType | |
| 6779 pNext*: pointer | |
| 6780 flags*: VkPipelineCoverageModulationStateCreateFlagsNV | |
| 6781 coverageModulationMode*: VkCoverageModulationModeNV | |
| 6782 coverageModulationTableEnable*: VkBool32 | |
| 6783 coverageModulationTableCount*: uint32 | |
| 6784 pCoverageModulationTable*: ptr float32 | |
| 6785 VkImageFormatListCreateInfo* = object | |
| 6786 sType*: VkStructureType | |
| 6787 pNext*: pointer | |
| 6788 viewFormatCount*: uint32 | |
| 6789 pViewFormats*: ptr VkFormat | |
| 6790 VkImageFormatListCreateInfoKHR* = object | |
| 6791 VkValidationCacheCreateInfoEXT* = object | |
| 6792 sType*: VkStructureType | |
| 6793 pNext*: pointer | |
| 6794 flags*: VkValidationCacheCreateFlagsEXT | |
| 6795 initialDataSize*: csize_t | |
| 6796 pInitialData*: pointer | |
| 6797 VkShaderModuleValidationCacheCreateInfoEXT* = object | |
| 6798 sType*: VkStructureType | |
| 6799 pNext*: pointer | |
| 6800 validationCache*: VkValidationCacheEXT | |
| 6801 VkPhysicalDeviceMaintenance3Properties* = object | |
| 6802 sType*: VkStructureType | |
| 6803 pNext*: pointer | |
| 6804 maxPerSetDescriptors*: uint32 | |
| 6805 maxMemoryAllocationSize*: VkDeviceSize | |
| 6806 VkPhysicalDeviceMaintenance3PropertiesKHR* = object | |
| 6807 VkPhysicalDeviceMaintenance4Features* = object | |
| 6808 sType*: VkStructureType | |
| 6809 pNext*: pointer | |
| 6810 maintenance4*: VkBool32 | |
| 6811 VkPhysicalDeviceMaintenance4FeaturesKHR* = object | |
| 6812 VkPhysicalDeviceMaintenance4Properties* = object | |
| 6813 sType*: VkStructureType | |
| 6814 pNext*: pointer | |
| 6815 maxBufferSize*: VkDeviceSize | |
| 6816 VkPhysicalDeviceMaintenance4PropertiesKHR* = object | |
| 6817 VkDescriptorSetLayoutSupport* = object | |
| 6818 sType*: VkStructureType | |
| 6819 pNext*: pointer | |
| 6820 supported*: VkBool32 | |
| 6821 VkDescriptorSetLayoutSupportKHR* = object | |
| 6822 VkPhysicalDeviceShaderDrawParametersFeatures* = object | |
| 6823 sType*: VkStructureType | |
| 6824 pNext*: pointer | |
| 6825 shaderDrawParameters*: VkBool32 | |
| 6826 VkPhysicalDeviceShaderDrawParameterFeatures* = object | |
| 6827 VkPhysicalDeviceShaderFloat16Int8Features* = object | |
| 6828 sType*: VkStructureType | |
| 6829 pNext*: pointer | |
| 6830 shaderFloat16*: VkBool32 | |
| 6831 shaderInt8*: VkBool32 | |
| 6832 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* = object | |
| 6833 VkPhysicalDeviceFloat16Int8FeaturesKHR* = object | |
| 6834 VkPhysicalDeviceFloatControlsProperties* = object | |
| 6835 sType*: VkStructureType | |
| 6836 pNext*: pointer | |
| 6837 denormBehaviorIndependence*: VkShaderFloatControlsIndependence | |
| 6838 roundingModeIndependence*: VkShaderFloatControlsIndependence | |
| 6839 shaderSignedZeroInfNanPreserveFloat16*: VkBool32 | |
| 6840 shaderSignedZeroInfNanPreserveFloat32*: VkBool32 | |
| 6841 shaderSignedZeroInfNanPreserveFloat64*: VkBool32 | |
| 6842 shaderDenormPreserveFloat16*: VkBool32 | |
| 6843 shaderDenormPreserveFloat32*: VkBool32 | |
| 6844 shaderDenormPreserveFloat64*: VkBool32 | |
| 6845 shaderDenormFlushToZeroFloat16*: VkBool32 | |
| 6846 shaderDenormFlushToZeroFloat32*: VkBool32 | |
| 6847 shaderDenormFlushToZeroFloat64*: VkBool32 | |
| 6848 shaderRoundingModeRTEFloat16*: VkBool32 | |
| 6849 shaderRoundingModeRTEFloat32*: VkBool32 | |
| 6850 shaderRoundingModeRTEFloat64*: VkBool32 | |
| 6851 shaderRoundingModeRTZFloat16*: VkBool32 | |
| 6852 shaderRoundingModeRTZFloat32*: VkBool32 | |
| 6853 shaderRoundingModeRTZFloat64*: VkBool32 | |
| 6854 VkPhysicalDeviceFloatControlsPropertiesKHR* = object | |
| 6855 VkPhysicalDeviceHostQueryResetFeatures* = object | |
| 6856 sType*: VkStructureType | |
| 6857 pNext*: pointer | |
| 6858 hostQueryReset*: VkBool32 | |
| 6859 VkPhysicalDeviceHostQueryResetFeaturesEXT* = object | |
| 6860 VkShaderResourceUsageAMD* = object | |
| 6861 numUsedVgprs*: uint32 | |
| 6862 numUsedSgprs*: uint32 | |
| 6863 ldsSizePerLocalWorkGroup*: uint32 | |
| 6864 ldsUsageSizeInBytes*: csize_t | |
| 6865 scratchMemUsageInBytes*: csize_t | |
| 6866 VkShaderStatisticsInfoAMD* = object | |
| 6867 shaderStageMask*: VkShaderStageFlags | |
| 6868 resourceUsage*: VkShaderResourceUsageAMD | |
| 6869 numPhysicalVgprs*: uint32 | |
| 6870 numPhysicalSgprs*: uint32 | |
| 6871 numAvailableVgprs*: uint32 | |
| 6872 numAvailableSgprs*: uint32 | |
| 6873 computeWorkGroupSize*: array[3, uint32] | |
| 6874 VkDeviceQueueGlobalPriorityCreateInfoKHR* = object | |
| 6875 sType*: VkStructureType | |
| 6876 pNext*: pointer | |
| 6877 globalPriority*: VkQueueGlobalPriorityKHR | |
| 6878 VkDeviceQueueGlobalPriorityCreateInfoEXT* = object | |
| 6879 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* = object | |
| 6880 sType*: VkStructureType | |
| 6881 pNext*: pointer | |
| 6882 globalPriorityQuery*: VkBool32 | |
| 6883 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* = object | |
| 6884 VkQueueFamilyGlobalPriorityPropertiesKHR* = object | |
| 6885 sType*: VkStructureType | |
| 6886 pNext*: pointer | |
| 6887 priorityCount*: uint32 | |
| 6888 priorities*: array[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR, VkQueueGlobalPriorityKHR] | |
| 6889 VkQueueFamilyGlobalPriorityPropertiesEXT* = object | |
| 6890 VkDebugUtilsObjectNameInfoEXT* = object | |
| 6891 sType*: VkStructureType | |
| 6892 pNext*: pointer | |
| 6893 objectType*: VkObjectType | |
| 6894 objectHandle*: uint64 | |
| 6895 pObjectName*: cstring | |
| 6896 VkDebugUtilsObjectTagInfoEXT* = object | |
| 6897 sType*: VkStructureType | |
| 6898 pNext*: pointer | |
| 6899 objectType*: VkObjectType | |
| 6900 objectHandle*: uint64 | |
| 6901 tagName*: uint64 | |
| 6902 tagSize*: csize_t | |
| 6903 pTag*: pointer | |
| 6904 VkDebugUtilsLabelEXT* = object | |
| 6905 sType*: VkStructureType | |
| 6906 pNext*: pointer | |
| 6907 pLabelName*: cstring | |
| 6908 color*: array[4, float32] | |
| 6909 VkDebugUtilsMessengerCreateInfoEXT* = object | |
| 6910 sType*: VkStructureType | |
| 6911 pNext*: pointer | |
| 6912 flags*: VkDebugUtilsMessengerCreateFlagsEXT | |
| 6913 messageSeverity*: VkDebugUtilsMessageSeverityFlagsEXT | |
| 6914 messageType*: VkDebugUtilsMessageTypeFlagsEXT | |
| 6915 pfnUserCallback*: PFN_vkDebugUtilsMessengerCallbackEXT | |
| 6916 pUserData*: pointer | |
| 6917 VkDebugUtilsMessengerCallbackDataEXT* = object | |
| 6918 sType*: VkStructureType | |
| 6919 pNext*: pointer | |
| 6920 flags*: VkDebugUtilsMessengerCallbackDataFlagsEXT | |
| 6921 pMessageIdName*: cstring | |
| 6922 messageIdNumber*: int32 | |
| 6923 pMessage*: cstring | |
| 6924 queueLabelCount*: uint32 | |
| 6925 pQueueLabels*: ptr VkDebugUtilsLabelEXT | |
| 6926 cmdBufLabelCount*: uint32 | |
| 6927 pCmdBufLabels*: ptr VkDebugUtilsLabelEXT | |
| 6928 objectCount*: uint32 | |
| 6929 pObjects*: ptr VkDebugUtilsObjectNameInfoEXT | |
| 6930 VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* = object | |
| 6931 sType*: VkStructureType | |
| 6932 pNext*: pointer | |
| 6933 deviceMemoryReport*: VkBool32 | |
| 6934 VkDeviceDeviceMemoryReportCreateInfoEXT* = object | |
| 6935 sType*: VkStructureType | |
| 6936 pNext*: pointer | |
| 6937 flags*: VkDeviceMemoryReportFlagsEXT | |
| 6938 pfnUserCallback*: PFN_vkDeviceMemoryReportCallbackEXT | |
| 6939 pUserData*: pointer | |
| 6940 VkDeviceMemoryReportCallbackDataEXT* = object | |
| 6941 sType*: VkStructureType | |
| 6942 pNext*: pointer | |
| 6943 flags*: VkDeviceMemoryReportFlagsEXT | |
| 6944 thetype*: VkDeviceMemoryReportEventTypeEXT | |
| 6945 memoryObjectId*: uint64 | |
| 6946 size*: VkDeviceSize | |
| 6947 objectType*: VkObjectType | |
| 6948 objectHandle*: uint64 | |
| 6949 heapIndex*: uint32 | |
| 6950 VkImportMemoryHostPointerInfoEXT* = object | |
| 6951 sType*: VkStructureType | |
| 6952 pNext*: pointer | |
| 6953 handleType*: VkExternalMemoryHandleTypeFlagBits | |
| 6954 pHostPointer*: pointer | |
| 6955 VkMemoryHostPointerPropertiesEXT* = object | |
| 6956 sType*: VkStructureType | |
| 6957 pNext*: pointer | |
| 6958 memoryTypeBits*: uint32 | |
| 6959 VkPhysicalDeviceExternalMemoryHostPropertiesEXT* = object | |
| 6960 sType*: VkStructureType | |
| 6961 pNext*: pointer | |
| 6962 minImportedHostPointerAlignment*: VkDeviceSize | |
| 6963 VkPhysicalDeviceConservativeRasterizationPropertiesEXT* = object | |
| 6964 sType*: VkStructureType | |
| 6965 pNext*: pointer | |
| 6966 primitiveOverestimationSize*: float32 | |
| 6967 maxExtraPrimitiveOverestimationSize*: float32 | |
| 6968 extraPrimitiveOverestimationSizeGranularity*: float32 | |
| 6969 primitiveUnderestimation*: VkBool32 | |
| 6970 conservativePointAndLineRasterization*: VkBool32 | |
| 6971 degenerateTrianglesRasterized*: VkBool32 | |
| 6972 degenerateLinesRasterized*: VkBool32 | |
| 6973 fullyCoveredFragmentShaderInputVariable*: VkBool32 | |
| 6974 conservativeRasterizationPostDepthCoverage*: VkBool32 | |
| 6975 VkCalibratedTimestampInfoEXT* = object | |
| 6976 sType*: VkStructureType | |
| 6977 pNext*: pointer | |
| 6978 timeDomain*: VkTimeDomainEXT | |
| 6979 VkPhysicalDeviceShaderCorePropertiesAMD* = object | |
| 6980 sType*: VkStructureType | |
| 6981 pNext*: pointer | |
| 6982 shaderEngineCount*: uint32 | |
| 6983 shaderArraysPerEngineCount*: uint32 | |
| 6984 computeUnitsPerShaderArray*: uint32 | |
| 6985 simdPerComputeUnit*: uint32 | |
| 6986 wavefrontsPerSimd*: uint32 | |
| 6987 wavefrontSize*: uint32 | |
| 6988 sgprsPerSimd*: uint32 | |
| 6989 minSgprAllocation*: uint32 | |
| 6990 maxSgprAllocation*: uint32 | |
| 6991 sgprAllocationGranularity*: uint32 | |
| 6992 vgprsPerSimd*: uint32 | |
| 6993 minVgprAllocation*: uint32 | |
| 6994 maxVgprAllocation*: uint32 | |
| 6995 vgprAllocationGranularity*: uint32 | |
| 6996 VkPhysicalDeviceShaderCoreProperties2AMD* = object | |
| 6997 sType*: VkStructureType | |
| 6998 pNext*: pointer | |
| 6999 shaderCoreFeatures*: VkShaderCorePropertiesFlagsAMD | |
| 7000 activeComputeUnitCount*: uint32 | |
| 7001 VkPipelineRasterizationConservativeStateCreateInfoEXT* = object | |
| 7002 sType*: VkStructureType | |
| 7003 pNext*: pointer | |
| 7004 flags*: VkPipelineRasterizationConservativeStateCreateFlagsEXT | |
| 7005 conservativeRasterizationMode*: VkConservativeRasterizationModeEXT | |
| 7006 extraPrimitiveOverestimationSize*: float32 | |
| 7007 VkPhysicalDeviceDescriptorIndexingFeatures* = object | |
| 7008 sType*: VkStructureType | |
| 7009 pNext*: pointer | |
| 7010 shaderInputAttachmentArrayDynamicIndexing*: VkBool32 | |
| 7011 shaderUniformTexelBufferArrayDynamicIndexing*: VkBool32 | |
| 7012 shaderStorageTexelBufferArrayDynamicIndexing*: VkBool32 | |
| 7013 shaderUniformBufferArrayNonUniformIndexing*: VkBool32 | |
| 7014 shaderSampledImageArrayNonUniformIndexing*: VkBool32 | |
| 7015 shaderStorageBufferArrayNonUniformIndexing*: VkBool32 | |
| 7016 shaderStorageImageArrayNonUniformIndexing*: VkBool32 | |
| 7017 shaderInputAttachmentArrayNonUniformIndexing*: VkBool32 | |
| 7018 shaderUniformTexelBufferArrayNonUniformIndexing*: VkBool32 | |
| 7019 shaderStorageTexelBufferArrayNonUniformIndexing*: VkBool32 | |
| 7020 descriptorBindingUniformBufferUpdateAfterBind*: VkBool32 | |
| 7021 descriptorBindingSampledImageUpdateAfterBind*: VkBool32 | |
| 7022 descriptorBindingStorageImageUpdateAfterBind*: VkBool32 | |
| 7023 descriptorBindingStorageBufferUpdateAfterBind*: VkBool32 | |
| 7024 descriptorBindingUniformTexelBufferUpdateAfterBind*: VkBool32 | |
| 7025 descriptorBindingStorageTexelBufferUpdateAfterBind*: VkBool32 | |
| 7026 descriptorBindingUpdateUnusedWhilePending*: VkBool32 | |
| 7027 descriptorBindingPartiallyBound*: VkBool32 | |
| 7028 descriptorBindingVariableDescriptorCount*: VkBool32 | |
| 7029 runtimeDescriptorArray*: VkBool32 | |
| 7030 VkPhysicalDeviceDescriptorIndexingFeaturesEXT* = object | |
| 7031 VkPhysicalDeviceDescriptorIndexingProperties* = object | |
| 7032 sType*: VkStructureType | |
| 7033 pNext*: pointer | |
| 7034 maxUpdateAfterBindDescriptorsInAllPools*: uint32 | |
| 7035 shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32 | |
| 7036 shaderSampledImageArrayNonUniformIndexingNative*: VkBool32 | |
| 7037 shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32 | |
| 7038 shaderStorageImageArrayNonUniformIndexingNative*: VkBool32 | |
| 7039 shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32 | |
| 7040 robustBufferAccessUpdateAfterBind*: VkBool32 | |
| 7041 quadDivergentImplicitLod*: VkBool32 | |
| 7042 maxPerStageDescriptorUpdateAfterBindSamplers*: uint32 | |
| 7043 maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32 | |
| 7044 maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32 | |
| 7045 maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32 | |
| 7046 maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32 | |
| 7047 maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32 | |
| 7048 maxPerStageUpdateAfterBindResources*: uint32 | |
| 7049 maxDescriptorSetUpdateAfterBindSamplers*: uint32 | |
| 7050 maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32 | |
| 7051 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32 | |
| 7052 maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32 | |
| 7053 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32 | |
| 7054 maxDescriptorSetUpdateAfterBindSampledImages*: uint32 | |
| 7055 maxDescriptorSetUpdateAfterBindStorageImages*: uint32 | |
| 7056 maxDescriptorSetUpdateAfterBindInputAttachments*: uint32 | |
| 7057 VkPhysicalDeviceDescriptorIndexingPropertiesEXT* = object | |
| 7058 VkDescriptorSetLayoutBindingFlagsCreateInfo* = object | |
| 7059 sType*: VkStructureType | |
| 7060 pNext*: pointer | |
| 7061 bindingCount*: uint32 | |
| 7062 pBindingFlags*: ptr VkDescriptorBindingFlags | |
| 7063 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* = object | |
| 7064 VkDescriptorSetVariableDescriptorCountAllocateInfo* = object | |
| 7065 sType*: VkStructureType | |
| 7066 pNext*: pointer | |
| 7067 descriptorSetCount*: uint32 | |
| 7068 pDescriptorCounts*: ptr uint32 | |
| 7069 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* = object | |
| 7070 VkDescriptorSetVariableDescriptorCountLayoutSupport* = object | |
| 7071 sType*: VkStructureType | |
| 7072 pNext*: pointer | |
| 7073 maxVariableDescriptorCount*: uint32 | |
| 7074 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* = object | |
| 7075 VkAttachmentDescription2* = object | |
| 7076 sType*: VkStructureType | |
| 7077 pNext*: pointer | |
| 7078 flags*: VkAttachmentDescriptionFlags | |
| 7079 format*: VkFormat | |
| 7080 samples*: VkSampleCountFlagBits | |
| 7081 loadOp*: VkAttachmentLoadOp | |
| 7082 storeOp*: VkAttachmentStoreOp | |
| 7083 stencilLoadOp*: VkAttachmentLoadOp | |
| 7084 stencilStoreOp*: VkAttachmentStoreOp | |
| 7085 initialLayout*: VkImageLayout | |
| 7086 finalLayout*: VkImageLayout | |
| 7087 VkAttachmentDescription2KHR* = object | |
| 7088 VkAttachmentReference2* = object | |
| 7089 sType*: VkStructureType | |
| 7090 pNext*: pointer | |
| 7091 attachment*: uint32 | |
| 7092 layout*: VkImageLayout | |
| 7093 aspectMask*: VkImageAspectFlags | |
| 7094 VkAttachmentReference2KHR* = object | |
| 7095 VkSubpassDescription2* = object | |
| 7096 sType*: VkStructureType | |
| 7097 pNext*: pointer | |
| 7098 flags*: VkSubpassDescriptionFlags | |
| 7099 pipelineBindPoint*: VkPipelineBindPoint | |
| 7100 viewMask*: uint32 | |
| 7101 inputAttachmentCount*: uint32 | |
| 7102 pInputAttachments*: ptr VkAttachmentReference2 | |
| 7103 colorAttachmentCount*: uint32 | |
| 7104 pColorAttachments*: ptr VkAttachmentReference2 | |
| 7105 pResolveAttachments*: ptr VkAttachmentReference2 | |
| 7106 pDepthStencilAttachment*: ptr VkAttachmentReference2 | |
| 7107 preserveAttachmentCount*: uint32 | |
| 7108 pPreserveAttachments*: ptr uint32 | |
| 7109 VkSubpassDescription2KHR* = object | |
| 7110 VkSubpassDependency2* = object | |
| 7111 sType*: VkStructureType | |
| 7112 pNext*: pointer | |
| 7113 srcSubpass*: uint32 | |
| 7114 dstSubpass*: uint32 | |
| 7115 srcStageMask*: VkPipelineStageFlags | |
| 7116 dstStageMask*: VkPipelineStageFlags | |
| 7117 srcAccessMask*: VkAccessFlags | |
| 7118 dstAccessMask*: VkAccessFlags | |
| 7119 dependencyFlags*: VkDependencyFlags | |
| 7120 viewOffset*: int32 | |
| 7121 VkSubpassDependency2KHR* = object | |
| 7122 VkRenderPassCreateInfo2* = object | |
| 7123 sType*: VkStructureType | |
| 7124 pNext*: pointer | |
| 7125 flags*: VkRenderPassCreateFlags | |
| 7126 attachmentCount*: uint32 | |
| 7127 pAttachments*: ptr VkAttachmentDescription2 | |
| 7128 subpassCount*: uint32 | |
| 7129 pSubpasses*: ptr VkSubpassDescription2 | |
| 7130 dependencyCount*: uint32 | |
| 7131 pDependencies*: ptr VkSubpassDependency2 | |
| 7132 correlatedViewMaskCount*: uint32 | |
| 7133 pCorrelatedViewMasks*: ptr uint32 | |
| 7134 VkRenderPassCreateInfo2KHR* = object | |
| 7135 VkSubpassBeginInfo* = object | |
| 7136 sType*: VkStructureType | |
| 7137 pNext*: pointer | |
| 7138 contents*: VkSubpassContents | |
| 7139 VkSubpassBeginInfoKHR* = object | |
| 7140 VkSubpassEndInfo* = object | |
| 7141 sType*: VkStructureType | |
| 7142 pNext*: pointer | |
| 7143 VkSubpassEndInfoKHR* = object | |
| 7144 VkPhysicalDeviceTimelineSemaphoreFeatures* = object | |
| 7145 sType*: VkStructureType | |
| 7146 pNext*: pointer | |
| 7147 timelineSemaphore*: VkBool32 | |
| 7148 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR* = object | |
| 7149 VkPhysicalDeviceTimelineSemaphoreProperties* = object | |
| 7150 sType*: VkStructureType | |
| 7151 pNext*: pointer | |
| 7152 maxTimelineSemaphoreValueDifference*: uint64 | |
| 7153 VkPhysicalDeviceTimelineSemaphorePropertiesKHR* = object | |
| 7154 VkSemaphoreTypeCreateInfo* = object | |
| 7155 sType*: VkStructureType | |
| 7156 pNext*: pointer | |
| 7157 semaphoreType*: VkSemaphoreType | |
| 7158 initialValue*: uint64 | |
| 7159 VkSemaphoreTypeCreateInfoKHR* = object | |
| 7160 VkTimelineSemaphoreSubmitInfo* = object | |
| 7161 sType*: VkStructureType | |
| 7162 pNext*: pointer | |
| 7163 waitSemaphoreValueCount*: uint32 | |
| 7164 pWaitSemaphoreValues*: ptr uint64 | |
| 7165 signalSemaphoreValueCount*: uint32 | |
| 7166 pSignalSemaphoreValues*: ptr uint64 | |
| 7167 VkTimelineSemaphoreSubmitInfoKHR* = object | |
| 7168 VkSemaphoreWaitInfo* = object | |
| 7169 sType*: VkStructureType | |
| 7170 pNext*: pointer | |
| 7171 flags*: VkSemaphoreWaitFlags | |
| 7172 semaphoreCount*: uint32 | |
| 7173 pSemaphores*: ptr VkSemaphore | |
| 7174 pValues*: ptr uint64 | |
| 7175 VkSemaphoreWaitInfoKHR* = object | |
| 7176 VkSemaphoreSignalInfo* = object | |
| 7177 sType*: VkStructureType | |
| 7178 pNext*: pointer | |
| 7179 semaphore*: VkSemaphore | |
| 7180 value*: uint64 | |
| 7181 VkSemaphoreSignalInfoKHR* = object | |
| 7182 VkVertexInputBindingDivisorDescriptionEXT* = object | |
| 7183 binding*: uint32 | |
| 7184 divisor*: uint32 | |
| 7185 VkPipelineVertexInputDivisorStateCreateInfoEXT* = object | |
| 7186 sType*: VkStructureType | |
| 7187 pNext*: pointer | |
| 7188 vertexBindingDivisorCount*: uint32 | |
| 7189 pVertexBindingDivisors*: ptr VkVertexInputBindingDivisorDescriptionEXT | |
| 7190 VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* = object | |
| 7191 sType*: VkStructureType | |
| 7192 pNext*: pointer | |
| 7193 maxVertexAttribDivisor*: uint32 | |
| 7194 VkPhysicalDevicePCIBusInfoPropertiesEXT* = object | |
| 7195 sType*: VkStructureType | |
| 7196 pNext*: pointer | |
| 7197 pciDomain*: uint32 | |
| 7198 pciBus*: uint32 | |
| 7199 pciDevice*: uint32 | |
| 7200 pciFunction*: uint32 | |
| 7201 VkCommandBufferInheritanceConditionalRenderingInfoEXT* = object | |
| 7202 sType*: VkStructureType | |
| 7203 pNext*: pointer | |
| 7204 conditionalRenderingEnable*: VkBool32 | |
| 7205 VkPhysicalDevice8BitStorageFeatures* = object | |
| 7206 sType*: VkStructureType | |
| 7207 pNext*: pointer | |
| 7208 storageBuffer8BitAccess*: VkBool32 | |
| 7209 uniformAndStorageBuffer8BitAccess*: VkBool32 | |
| 7210 storagePushConstant8*: VkBool32 | |
| 7211 VkPhysicalDevice8BitStorageFeaturesKHR* = object | |
| 7212 VkPhysicalDeviceConditionalRenderingFeaturesEXT* = object | |
| 7213 sType*: VkStructureType | |
| 7214 pNext*: pointer | |
| 7215 conditionalRendering*: VkBool32 | |
| 7216 inheritedConditionalRendering*: VkBool32 | |
| 7217 VkPhysicalDeviceVulkanMemoryModelFeatures* = object | |
| 7218 sType*: VkStructureType | |
| 7219 pNext*: pointer | |
| 7220 vulkanMemoryModel*: VkBool32 | |
| 7221 vulkanMemoryModelDeviceScope*: VkBool32 | |
| 7222 vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32 | |
| 7223 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* = object | |
| 7224 VkPhysicalDeviceShaderAtomicInt64Features* = object | |
| 7225 sType*: VkStructureType | |
| 7226 pNext*: pointer | |
| 7227 shaderBufferInt64Atomics*: VkBool32 | |
| 7228 shaderSharedInt64Atomics*: VkBool32 | |
| 7229 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* = object | |
| 7230 VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* = object | |
| 7231 sType*: VkStructureType | |
| 7232 pNext*: pointer | |
| 7233 shaderBufferFloat32Atomics*: VkBool32 | |
| 7234 shaderBufferFloat32AtomicAdd*: VkBool32 | |
| 7235 shaderBufferFloat64Atomics*: VkBool32 | |
| 7236 shaderBufferFloat64AtomicAdd*: VkBool32 | |
| 7237 shaderSharedFloat32Atomics*: VkBool32 | |
| 7238 shaderSharedFloat32AtomicAdd*: VkBool32 | |
| 7239 shaderSharedFloat64Atomics*: VkBool32 | |
| 7240 shaderSharedFloat64AtomicAdd*: VkBool32 | |
| 7241 shaderImageFloat32Atomics*: VkBool32 | |
| 7242 shaderImageFloat32AtomicAdd*: VkBool32 | |
| 7243 sparseImageFloat32Atomics*: VkBool32 | |
| 7244 sparseImageFloat32AtomicAdd*: VkBool32 | |
| 7245 VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* = object | |
| 7246 sType*: VkStructureType | |
| 7247 pNext*: pointer | |
| 7248 shaderBufferFloat16Atomics*: VkBool32 | |
| 7249 shaderBufferFloat16AtomicAdd*: VkBool32 | |
| 7250 shaderBufferFloat16AtomicMinMax*: VkBool32 | |
| 7251 shaderBufferFloat32AtomicMinMax*: VkBool32 | |
| 7252 shaderBufferFloat64AtomicMinMax*: VkBool32 | |
| 7253 shaderSharedFloat16Atomics*: VkBool32 | |
| 7254 shaderSharedFloat16AtomicAdd*: VkBool32 | |
| 7255 shaderSharedFloat16AtomicMinMax*: VkBool32 | |
| 7256 shaderSharedFloat32AtomicMinMax*: VkBool32 | |
| 7257 shaderSharedFloat64AtomicMinMax*: VkBool32 | |
| 7258 shaderImageFloat32AtomicMinMax*: VkBool32 | |
| 7259 sparseImageFloat32AtomicMinMax*: VkBool32 | |
| 7260 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* = object | |
| 7261 sType*: VkStructureType | |
| 7262 pNext*: pointer | |
| 7263 vertexAttributeInstanceRateDivisor*: VkBool32 | |
| 7264 vertexAttributeInstanceRateZeroDivisor*: VkBool32 | |
| 7265 VkQueueFamilyCheckpointPropertiesNV* = object | |
| 7266 sType*: VkStructureType | |
| 7267 pNext*: pointer | |
| 7268 checkpointExecutionStageMask*: VkPipelineStageFlags | |
| 7269 VkCheckpointDataNV* = object | |
| 7270 sType*: VkStructureType | |
| 7271 pNext*: pointer | |
| 7272 stage*: VkPipelineStageFlagBits | |
| 7273 pCheckpointMarker*: pointer | |
| 7274 VkPhysicalDeviceDepthStencilResolveProperties* = object | |
| 7275 sType*: VkStructureType | |
| 7276 pNext*: pointer | |
| 7277 supportedDepthResolveModes*: VkResolveModeFlags | |
| 7278 supportedStencilResolveModes*: VkResolveModeFlags | |
| 7279 independentResolveNone*: VkBool32 | |
| 7280 independentResolve*: VkBool32 | |
| 7281 VkPhysicalDeviceDepthStencilResolvePropertiesKHR* = object | |
| 7282 VkSubpassDescriptionDepthStencilResolve* = object | |
| 7283 sType*: VkStructureType | |
| 7284 pNext*: pointer | |
| 7285 depthResolveMode*: VkResolveModeFlagBits | |
| 7286 stencilResolveMode*: VkResolveModeFlagBits | |
| 7287 pDepthStencilResolveAttachment*: ptr VkAttachmentReference2 | |
| 7288 VkSubpassDescriptionDepthStencilResolveKHR* = object | |
| 7289 VkImageViewASTCDecodeModeEXT* = object | |
| 7290 sType*: VkStructureType | |
| 7291 pNext*: pointer | |
| 7292 decodeMode*: VkFormat | |
| 7293 VkPhysicalDeviceASTCDecodeFeaturesEXT* = object | |
| 7294 sType*: VkStructureType | |
| 7295 pNext*: pointer | |
| 7296 decodeModeSharedExponent*: VkBool32 | |
| 7297 VkPhysicalDeviceTransformFeedbackFeaturesEXT* = object | |
| 7298 sType*: VkStructureType | |
| 7299 pNext*: pointer | |
| 7300 transformFeedback*: VkBool32 | |
| 7301 geometryStreams*: VkBool32 | |
| 7302 VkPhysicalDeviceTransformFeedbackPropertiesEXT* = object | |
| 7303 sType*: VkStructureType | |
| 7304 pNext*: pointer | |
| 7305 maxTransformFeedbackStreams*: uint32 | |
| 7306 maxTransformFeedbackBuffers*: uint32 | |
| 7307 maxTransformFeedbackBufferSize*: VkDeviceSize | |
| 7308 maxTransformFeedbackStreamDataSize*: uint32 | |
| 7309 maxTransformFeedbackBufferDataSize*: uint32 | |
| 7310 maxTransformFeedbackBufferDataStride*: uint32 | |
| 7311 transformFeedbackQueries*: VkBool32 | |
| 7312 transformFeedbackStreamsLinesTriangles*: VkBool32 | |
| 7313 transformFeedbackRasterizationStreamSelect*: VkBool32 | |
| 7314 transformFeedbackDraw*: VkBool32 | |
| 7315 VkPipelineRasterizationStateStreamCreateInfoEXT* = object | |
| 7316 sType*: VkStructureType | |
| 7317 pNext*: pointer | |
| 7318 flags*: VkPipelineRasterizationStateStreamCreateFlagsEXT | |
| 7319 rasterizationStream*: uint32 | |
| 7320 VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* = object | |
| 7321 sType*: VkStructureType | |
| 7322 pNext*: pointer | |
| 7323 representativeFragmentTest*: VkBool32 | |
| 7324 VkPipelineRepresentativeFragmentTestStateCreateInfoNV* = object | |
| 7325 sType*: VkStructureType | |
| 7326 pNext*: pointer | |
| 7327 representativeFragmentTestEnable*: VkBool32 | |
| 7328 VkPhysicalDeviceExclusiveScissorFeaturesNV* = object | |
| 7329 sType*: VkStructureType | |
| 7330 pNext*: pointer | |
| 7331 exclusiveScissor*: VkBool32 | |
| 7332 VkPipelineViewportExclusiveScissorStateCreateInfoNV* = object | |
| 7333 sType*: VkStructureType | |
| 7334 pNext*: pointer | |
| 7335 exclusiveScissorCount*: uint32 | |
| 7336 pExclusiveScissors*: ptr VkRect2D | |
| 7337 VkPhysicalDeviceCornerSampledImageFeaturesNV* = object | |
| 7338 sType*: VkStructureType | |
| 7339 pNext*: pointer | |
| 7340 cornerSampledImage*: VkBool32 | |
| 7341 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* = object | |
| 7342 sType*: VkStructureType | |
| 7343 pNext*: pointer | |
| 7344 computeDerivativeGroupQuads*: VkBool32 | |
| 7345 computeDerivativeGroupLinear*: VkBool32 | |
| 7346 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* = object | |
| 7347 VkPhysicalDeviceShaderImageFootprintFeaturesNV* = object | |
| 7348 sType*: VkStructureType | |
| 7349 pNext*: pointer | |
| 7350 imageFootprint*: VkBool32 | |
| 7351 VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* = object | |
| 7352 sType*: VkStructureType | |
| 7353 pNext*: pointer | |
| 7354 dedicatedAllocationImageAliasing*: VkBool32 | |
| 7355 VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* = object | |
| 7356 sType*: VkStructureType | |
| 7357 pNext*: pointer | |
| 7358 indirectCopy*: VkBool32 | |
| 7359 VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* = object | |
| 7360 sType*: VkStructureType | |
| 7361 pNext*: pointer | |
| 7362 supportedQueues*: VkQueueFlags | |
| 7363 VkPhysicalDeviceMemoryDecompressionFeaturesNV* = object | |
| 7364 sType*: VkStructureType | |
| 7365 pNext*: pointer | |
| 7366 memoryDecompression*: VkBool32 | |
| 7367 VkPhysicalDeviceMemoryDecompressionPropertiesNV* = object | |
| 7368 sType*: VkStructureType | |
| 7369 pNext*: pointer | |
| 7370 decompressionMethods*: VkMemoryDecompressionMethodFlagsNV | |
| 7371 maxDecompressionIndirectCount*: uint64 | |
| 7372 VkShadingRatePaletteNV* = object | |
| 7373 shadingRatePaletteEntryCount*: uint32 | |
| 7374 pShadingRatePaletteEntries*: ptr VkShadingRatePaletteEntryNV | |
| 7375 VkPipelineViewportShadingRateImageStateCreateInfoNV* = object | |
| 7376 sType*: VkStructureType | |
| 7377 pNext*: pointer | |
| 7378 shadingRateImageEnable*: VkBool32 | |
| 7379 viewportCount*: uint32 | |
| 7380 pShadingRatePalettes*: ptr VkShadingRatePaletteNV | |
| 7381 VkPhysicalDeviceShadingRateImageFeaturesNV* = object | |
| 7382 sType*: VkStructureType | |
| 7383 pNext*: pointer | |
| 7384 shadingRateImage*: VkBool32 | |
| 7385 shadingRateCoarseSampleOrder*: VkBool32 | |
| 7386 VkPhysicalDeviceShadingRateImagePropertiesNV* = object | |
| 7387 sType*: VkStructureType | |
| 7388 pNext*: pointer | |
| 7389 shadingRateTexelSize*: VkExtent2D | |
| 7390 shadingRatePaletteSize*: uint32 | |
| 7391 shadingRateMaxCoarseSamples*: uint32 | |
| 7392 VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* = object | |
| 7393 sType*: VkStructureType | |
| 7394 pNext*: pointer | |
| 7395 invocationMask*: VkBool32 | |
| 7396 VkCoarseSampleLocationNV* = object | |
| 7397 pixelX*: uint32 | |
| 7398 pixelY*: uint32 | |
| 7399 sample*: uint32 | |
| 7400 VkCoarseSampleOrderCustomNV* = object | |
| 7401 shadingRate*: VkShadingRatePaletteEntryNV | |
| 7402 sampleCount*: uint32 | |
| 7403 sampleLocationCount*: uint32 | |
| 7404 pSampleLocations*: ptr VkCoarseSampleLocationNV | |
| 7405 VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* = object | |
| 7406 sType*: VkStructureType | |
| 7407 pNext*: pointer | |
| 7408 sampleOrderType*: VkCoarseSampleOrderTypeNV | |
| 7409 customSampleOrderCount*: uint32 | |
| 7410 pCustomSampleOrders*: ptr VkCoarseSampleOrderCustomNV | |
| 7411 VkPhysicalDeviceMeshShaderFeaturesNV* = object | |
| 7412 sType*: VkStructureType | |
| 7413 pNext*: pointer | |
| 7414 taskShader*: VkBool32 | |
| 7415 meshShader*: VkBool32 | |
| 7416 VkPhysicalDeviceMeshShaderPropertiesNV* = object | |
| 7417 sType*: VkStructureType | |
| 7418 pNext*: pointer | |
| 7419 maxDrawMeshTasksCount*: uint32 | |
| 7420 maxTaskWorkGroupInvocations*: uint32 | |
| 7421 maxTaskWorkGroupSize*: array[3, uint32] | |
| 7422 maxTaskTotalMemorySize*: uint32 | |
| 7423 maxTaskOutputCount*: uint32 | |
| 7424 maxMeshWorkGroupInvocations*: uint32 | |
| 7425 maxMeshWorkGroupSize*: array[3, uint32] | |
| 7426 maxMeshTotalMemorySize*: uint32 | |
| 7427 maxMeshOutputVertices*: uint32 | |
| 7428 maxMeshOutputPrimitives*: uint32 | |
| 7429 maxMeshMultiviewViewCount*: uint32 | |
| 7430 meshOutputPerVertexGranularity*: uint32 | |
| 7431 meshOutputPerPrimitiveGranularity*: uint32 | |
| 7432 VkDrawMeshTasksIndirectCommandNV* = object | |
| 7433 taskCount*: uint32 | |
| 7434 firstTask*: uint32 | |
| 7435 VkPhysicalDeviceMeshShaderFeaturesEXT* = object | |
| 7436 sType*: VkStructureType | |
| 7437 pNext*: pointer | |
| 7438 taskShader*: VkBool32 | |
| 7439 meshShader*: VkBool32 | |
| 7440 multiviewMeshShader*: VkBool32 | |
| 7441 primitiveFragmentShadingRateMeshShader*: VkBool32 | |
| 7442 meshShaderQueries*: VkBool32 | |
| 7443 VkPhysicalDeviceMeshShaderPropertiesEXT* = object | |
| 7444 sType*: VkStructureType | |
| 7445 pNext*: pointer | |
| 7446 maxTaskWorkGroupTotalCount*: uint32 | |
| 7447 maxTaskWorkGroupCount*: array[3, uint32] | |
| 7448 maxTaskWorkGroupInvocations*: uint32 | |
| 7449 maxTaskWorkGroupSize*: array[3, uint32] | |
| 7450 maxTaskPayloadSize*: uint32 | |
| 7451 maxTaskSharedMemorySize*: uint32 | |
| 7452 maxTaskPayloadAndSharedMemorySize*: uint32 | |
| 7453 maxMeshWorkGroupTotalCount*: uint32 | |
| 7454 maxMeshWorkGroupCount*: array[3, uint32] | |
| 7455 maxMeshWorkGroupInvocations*: uint32 | |
| 7456 maxMeshWorkGroupSize*: array[3, uint32] | |
| 7457 maxMeshSharedMemorySize*: uint32 | |
| 7458 maxMeshPayloadAndSharedMemorySize*: uint32 | |
| 7459 maxMeshOutputMemorySize*: uint32 | |
| 7460 maxMeshPayloadAndOutputMemorySize*: uint32 | |
| 7461 maxMeshOutputComponents*: uint32 | |
| 7462 maxMeshOutputVertices*: uint32 | |
| 7463 maxMeshOutputPrimitives*: uint32 | |
| 7464 maxMeshOutputLayers*: uint32 | |
| 7465 maxMeshMultiviewViewCount*: uint32 | |
| 7466 meshOutputPerVertexGranularity*: uint32 | |
| 7467 meshOutputPerPrimitiveGranularity*: uint32 | |
| 7468 maxPreferredTaskWorkGroupInvocations*: uint32 | |
| 7469 maxPreferredMeshWorkGroupInvocations*: uint32 | |
| 7470 prefersLocalInvocationVertexOutput*: VkBool32 | |
| 7471 prefersLocalInvocationPrimitiveOutput*: VkBool32 | |
| 7472 prefersCompactVertexOutput*: VkBool32 | |
| 7473 prefersCompactPrimitiveOutput*: VkBool32 | |
| 7474 VkDrawMeshTasksIndirectCommandEXT* = object | |
| 7475 groupCountX*: uint32 | |
| 7476 groupCountY*: uint32 | |
| 7477 groupCountZ*: uint32 | |
| 7478 VkRayTracingShaderGroupCreateInfoNV* = object | |
| 7479 sType*: VkStructureType | |
| 7480 pNext*: pointer | |
| 7481 thetype*: VkRayTracingShaderGroupTypeKHR | |
| 7482 generalShader*: uint32 | |
| 7483 closestHitShader*: uint32 | |
| 7484 anyHitShader*: uint32 | |
| 7485 intersectionShader*: uint32 | |
| 7486 VkRayTracingShaderGroupCreateInfoKHR* = object | |
| 7487 sType*: VkStructureType | |
| 7488 pNext*: pointer | |
| 7489 thetype*: VkRayTracingShaderGroupTypeKHR | |
| 7490 generalShader*: uint32 | |
| 7491 closestHitShader*: uint32 | |
| 7492 anyHitShader*: uint32 | |
| 7493 intersectionShader*: uint32 | |
| 7494 pShaderGroupCaptureReplayHandle*: pointer | |
| 7495 VkRayTracingPipelineCreateInfoNV* = object | |
| 7496 sType*: VkStructureType | |
| 7497 pNext*: pointer | |
| 7498 flags*: VkPipelineCreateFlags | |
| 7499 stageCount*: uint32 | |
| 7500 pStages*: ptr VkPipelineShaderStageCreateInfo | |
| 7501 groupCount*: uint32 | |
| 7502 pGroups*: ptr VkRayTracingShaderGroupCreateInfoNV | |
| 7503 maxRecursionDepth*: uint32 | |
| 7504 layout*: VkPipelineLayout | |
| 7505 basePipelineHandle*: VkPipeline | |
| 7506 basePipelineIndex*: int32 | |
| 7507 VkRayTracingPipelineCreateInfoKHR* = object | |
| 7508 sType*: VkStructureType | |
| 7509 pNext*: pointer | |
| 7510 flags*: VkPipelineCreateFlags | |
| 7511 stageCount*: uint32 | |
| 7512 pStages*: ptr VkPipelineShaderStageCreateInfo | |
| 7513 groupCount*: uint32 | |
| 7514 pGroups*: ptr VkRayTracingShaderGroupCreateInfoKHR | |
| 7515 maxPipelineRayRecursionDepth*: uint32 | |
| 7516 pLibraryInfo*: ptr VkPipelineLibraryCreateInfoKHR | |
| 7517 pLibraryInterface*: ptr VkRayTracingPipelineInterfaceCreateInfoKHR | |
| 7518 pDynamicState*: ptr VkPipelineDynamicStateCreateInfo | |
| 7519 layout*: VkPipelineLayout | |
| 7520 basePipelineHandle*: VkPipeline | |
| 7521 basePipelineIndex*: int32 | |
| 7522 VkGeometryTrianglesNV* = object | |
| 7523 sType*: VkStructureType | |
| 7524 pNext*: pointer | |
| 7525 vertexData*: VkBuffer | |
| 7526 vertexOffset*: VkDeviceSize | |
| 7527 vertexCount*: uint32 | |
| 7528 vertexStride*: VkDeviceSize | |
| 7529 vertexFormat*: VkFormat | |
| 7530 indexData*: VkBuffer | |
| 7531 indexOffset*: VkDeviceSize | |
| 7532 indexCount*: uint32 | |
| 7533 indexType*: VkIndexType | |
| 7534 transformData*: VkBuffer | |
| 7535 transformOffset*: VkDeviceSize | |
| 7536 VkGeometryAABBNV* = object | |
| 7537 sType*: VkStructureType | |
| 7538 pNext*: pointer | |
| 7539 aabbData*: VkBuffer | |
| 7540 numAABBs*: uint32 | |
| 7541 stride*: uint32 | |
| 7542 offset*: VkDeviceSize | |
| 7543 VkGeometryDataNV* = object | |
| 7544 triangles*: VkGeometryTrianglesNV | |
| 7545 aabbs*: VkGeometryAABBNV | |
| 7546 VkGeometryNV* = object | |
| 7547 sType*: VkStructureType | |
| 7548 pNext*: pointer | |
| 7549 geometryType*: VkGeometryTypeKHR | |
| 7550 geometry*: VkGeometryDataNV | |
| 7551 flags*: VkGeometryFlagsKHR | |
| 7552 VkAccelerationStructureInfoNV* = object | |
| 7553 sType*: VkStructureType | |
| 7554 pNext*: pointer | |
| 7555 thetype*: VkAccelerationStructureTypeNV | |
| 7556 flags*: VkBuildAccelerationStructureFlagsNV | |
| 7557 instanceCount*: uint32 | |
| 7558 geometryCount*: uint32 | |
| 7559 pGeometries*: ptr VkGeometryNV | |
| 7560 VkAccelerationStructureCreateInfoNV* = object | |
| 7561 sType*: VkStructureType | |
| 7562 pNext*: pointer | |
| 7563 compactedSize*: VkDeviceSize | |
| 7564 info*: VkAccelerationStructureInfoNV | |
| 7565 VkBindAccelerationStructureMemoryInfoNV* = object | |
| 7566 sType*: VkStructureType | |
| 7567 pNext*: pointer | |
| 7568 accelerationStructure*: VkAccelerationStructureNV | |
| 7569 memory*: VkDeviceMemory | |
| 7570 memoryOffset*: VkDeviceSize | |
| 7571 deviceIndexCount*: uint32 | |
| 7572 pDeviceIndices*: ptr uint32 | |
| 7573 VkWriteDescriptorSetAccelerationStructureKHR* = object | |
| 7574 sType*: VkStructureType | |
| 7575 pNext*: pointer | |
| 7576 accelerationStructureCount*: uint32 | |
| 7577 pAccelerationStructures*: ptr VkAccelerationStructureKHR | |
| 7578 VkWriteDescriptorSetAccelerationStructureNV* = object | |
| 7579 sType*: VkStructureType | |
| 7580 pNext*: pointer | |
| 7581 accelerationStructureCount*: uint32 | |
| 7582 pAccelerationStructures*: ptr VkAccelerationStructureNV | |
| 7583 VkAccelerationStructureMemoryRequirementsInfoNV* = object | |
| 7584 sType*: VkStructureType | |
| 7585 pNext*: pointer | |
| 7586 thetype*: VkAccelerationStructureMemoryRequirementsTypeNV | |
| 7587 accelerationStructure*: VkAccelerationStructureNV | |
| 7588 VkPhysicalDeviceAccelerationStructureFeaturesKHR* = object | |
| 7589 sType*: VkStructureType | |
| 7590 pNext*: pointer | |
| 7591 accelerationStructure*: VkBool32 | |
| 7592 accelerationStructureCaptureReplay*: VkBool32 | |
| 7593 accelerationStructureIndirectBuild*: VkBool32 | |
| 7594 accelerationStructureHostCommands*: VkBool32 | |
| 7595 descriptorBindingAccelerationStructureUpdateAfterBind*: VkBool32 | |
| 7596 VkPhysicalDeviceRayTracingPipelineFeaturesKHR* = object | |
| 7597 sType*: VkStructureType | |
| 7598 pNext*: pointer | |
| 7599 rayTracingPipeline*: VkBool32 | |
| 7600 rayTracingPipelineShaderGroupHandleCaptureReplay*: VkBool32 | |
| 7601 rayTracingPipelineShaderGroupHandleCaptureReplayMixed*: VkBool32 | |
| 7602 rayTracingPipelineTraceRaysIndirect*: VkBool32 | |
| 7603 rayTraversalPrimitiveCulling*: VkBool32 | |
| 7604 VkPhysicalDeviceRayQueryFeaturesKHR* = object | |
| 7605 sType*: VkStructureType | |
| 7606 pNext*: pointer | |
| 7607 rayQuery*: VkBool32 | |
| 7608 VkPhysicalDeviceAccelerationStructurePropertiesKHR* = object | |
| 7609 sType*: VkStructureType | |
| 7610 pNext*: pointer | |
| 7611 maxGeometryCount*: uint64 | |
| 7612 maxInstanceCount*: uint64 | |
| 7613 maxPrimitiveCount*: uint64 | |
| 7614 maxPerStageDescriptorAccelerationStructures*: uint32 | |
| 7615 maxPerStageDescriptorUpdateAfterBindAccelerationStructures*: uint32 | |
| 7616 maxDescriptorSetAccelerationStructures*: uint32 | |
| 7617 maxDescriptorSetUpdateAfterBindAccelerationStructures*: uint32 | |
| 7618 minAccelerationStructureScratchOffsetAlignment*: uint32 | |
| 7619 VkPhysicalDeviceRayTracingPipelinePropertiesKHR* = object | |
| 7620 sType*: VkStructureType | |
| 7621 pNext*: pointer | |
| 7622 shaderGroupHandleSize*: uint32 | |
| 7623 maxRayRecursionDepth*: uint32 | |
| 7624 maxShaderGroupStride*: uint32 | |
| 7625 shaderGroupBaseAlignment*: uint32 | |
| 7626 shaderGroupHandleCaptureReplaySize*: uint32 | |
| 7627 maxRayDispatchInvocationCount*: uint32 | |
| 7628 shaderGroupHandleAlignment*: uint32 | |
| 7629 maxRayHitAttributeSize*: uint32 | |
| 7630 VkPhysicalDeviceRayTracingPropertiesNV* = object | |
| 7631 sType*: VkStructureType | |
| 7632 pNext*: pointer | |
| 7633 shaderGroupHandleSize*: uint32 | |
| 7634 maxRecursionDepth*: uint32 | |
| 7635 maxShaderGroupStride*: uint32 | |
| 7636 shaderGroupBaseAlignment*: uint32 | |
| 7637 maxGeometryCount*: uint64 | |
| 7638 maxInstanceCount*: uint64 | |
| 7639 maxTriangleCount*: uint64 | |
| 7640 maxDescriptorSetAccelerationStructures*: uint32 | |
| 7641 VkStridedDeviceAddressRegionKHR* = object | |
| 7642 deviceAddress*: VkDeviceAddress | |
| 7643 stride*: VkDeviceSize | |
| 7644 size*: VkDeviceSize | |
| 7645 VkTraceRaysIndirectCommandKHR* = object | |
| 7646 width*: uint32 | |
| 7647 height*: uint32 | |
| 7648 depth*: uint32 | |
| 7649 VkTraceRaysIndirectCommand2KHR* = object | |
| 7650 raygenShaderRecordAddress*: VkDeviceAddress | |
| 7651 raygenShaderRecordSize*: VkDeviceSize | |
| 7652 missShaderBindingTableAddress*: VkDeviceAddress | |
| 7653 missShaderBindingTableSize*: VkDeviceSize | |
| 7654 missShaderBindingTableStride*: VkDeviceSize | |
| 7655 hitShaderBindingTableAddress*: VkDeviceAddress | |
| 7656 hitShaderBindingTableSize*: VkDeviceSize | |
| 7657 hitShaderBindingTableStride*: VkDeviceSize | |
| 7658 callableShaderBindingTableAddress*: VkDeviceAddress | |
| 7659 callableShaderBindingTableSize*: VkDeviceSize | |
| 7660 callableShaderBindingTableStride*: VkDeviceSize | |
| 7661 width*: uint32 | |
| 7662 height*: uint32 | |
| 7663 depth*: uint32 | |
| 7664 VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* = object | |
| 7665 sType*: VkStructureType | |
| 7666 pNext*: pointer | |
| 7667 rayTracingMaintenance1*: VkBool32 | |
| 7668 rayTracingPipelineTraceRaysIndirect2*: VkBool32 | |
| 7669 VkDrmFormatModifierPropertiesListEXT* = object | |
| 7670 sType*: VkStructureType | |
| 7671 pNext*: pointer | |
| 7672 drmFormatModifierCount*: uint32 | |
| 7673 pDrmFormatModifierProperties*: ptr VkDrmFormatModifierPropertiesEXT | |
| 7674 VkDrmFormatModifierPropertiesEXT* = object | |
| 7675 drmFormatModifier*: uint64 | |
| 7676 drmFormatModifierPlaneCount*: uint32 | |
| 7677 drmFormatModifierTilingFeatures*: VkFormatFeatureFlags | |
| 7678 VkPhysicalDeviceImageDrmFormatModifierInfoEXT* = object | |
| 7679 sType*: VkStructureType | |
| 7680 pNext*: pointer | |
| 7681 drmFormatModifier*: uint64 | |
| 7682 sharingMode*: VkSharingMode | |
| 7683 queueFamilyIndexCount*: uint32 | |
| 7684 pQueueFamilyIndices*: ptr uint32 | |
| 7685 VkImageDrmFormatModifierListCreateInfoEXT* = object | |
| 7686 sType*: VkStructureType | |
| 7687 pNext*: pointer | |
| 7688 drmFormatModifierCount*: uint32 | |
| 7689 pDrmFormatModifiers*: ptr uint64 | |
| 7690 VkImageDrmFormatModifierExplicitCreateInfoEXT* = object | |
| 7691 sType*: VkStructureType | |
| 7692 pNext*: pointer | |
| 7693 drmFormatModifier*: uint64 | |
| 7694 drmFormatModifierPlaneCount*: uint32 | |
| 7695 pPlaneLayouts*: ptr VkSubresourceLayout | |
| 7696 VkImageDrmFormatModifierPropertiesEXT* = object | |
| 7697 sType*: VkStructureType | |
| 7698 pNext*: pointer | |
| 7699 drmFormatModifier*: uint64 | |
| 7700 VkImageStencilUsageCreateInfo* = object | |
| 7701 sType*: VkStructureType | |
| 7702 pNext*: pointer | |
| 7703 stencilUsage*: VkImageUsageFlags | |
| 7704 VkImageStencilUsageCreateInfoEXT* = object | |
| 7705 VkDeviceMemoryOverallocationCreateInfoAMD* = object | |
| 7706 sType*: VkStructureType | |
| 7707 pNext*: pointer | |
| 7708 overallocationBehavior*: VkMemoryOverallocationBehaviorAMD | |
| 7709 VkPhysicalDeviceFragmentDensityMapFeaturesEXT* = object | |
| 7710 sType*: VkStructureType | |
| 7711 pNext*: pointer | |
| 7712 fragmentDensityMap*: VkBool32 | |
| 7713 fragmentDensityMapDynamic*: VkBool32 | |
| 7714 fragmentDensityMapNonSubsampledImages*: VkBool32 | |
| 7715 VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* = object | |
| 7716 sType*: VkStructureType | |
| 7717 pNext*: pointer | |
| 7718 fragmentDensityMapDeferred*: VkBool32 | |
| 7719 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* = object | |
| 7720 sType*: VkStructureType | |
| 7721 pNext*: pointer | |
| 7722 fragmentDensityMapOffset*: VkBool32 | |
| 7723 VkPhysicalDeviceFragmentDensityMapPropertiesEXT* = object | |
| 7724 sType*: VkStructureType | |
| 7725 pNext*: pointer | |
| 7726 minFragmentDensityTexelSize*: VkExtent2D | |
| 7727 maxFragmentDensityTexelSize*: VkExtent2D | |
| 7728 fragmentDensityInvocations*: VkBool32 | |
| 7729 VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* = object | |
| 7730 sType*: VkStructureType | |
| 7731 pNext*: pointer | |
| 7732 subsampledLoads*: VkBool32 | |
| 7733 subsampledCoarseReconstructionEarlyAccess*: VkBool32 | |
| 7734 maxSubsampledArrayLayers*: uint32 | |
| 7735 maxDescriptorSetSubsampledSamplers*: uint32 | |
| 7736 VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* = object | |
| 7737 sType*: VkStructureType | |
| 7738 pNext*: pointer | |
| 7739 fragmentDensityOffsetGranularity*: VkExtent2D | |
| 7740 VkRenderPassFragmentDensityMapCreateInfoEXT* = object | |
| 7741 sType*: VkStructureType | |
| 7742 pNext*: pointer | |
| 7743 fragmentDensityMapAttachment*: VkAttachmentReference | |
| 7744 VkSubpassFragmentDensityMapOffsetEndInfoQCOM* = object | |
| 7745 sType*: VkStructureType | |
| 7746 pNext*: pointer | |
| 7747 fragmentDensityOffsetCount*: uint32 | |
| 7748 pFragmentDensityOffsets*: ptr VkOffset2D | |
| 7749 VkPhysicalDeviceScalarBlockLayoutFeatures* = object | |
| 7750 sType*: VkStructureType | |
| 7751 pNext*: pointer | |
| 7752 scalarBlockLayout*: VkBool32 | |
| 7753 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* = object | |
| 7754 VkSurfaceProtectedCapabilitiesKHR* = object | |
| 7755 sType*: VkStructureType | |
| 7756 pNext*: pointer | |
| 7757 supportsProtected*: VkBool32 | |
| 7758 VkPhysicalDeviceUniformBufferStandardLayoutFeatures* = object | |
| 7759 sType*: VkStructureType | |
| 7760 pNext*: pointer | |
| 7761 uniformBufferStandardLayout*: VkBool32 | |
| 7762 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* = object | |
| 7763 VkPhysicalDeviceDepthClipEnableFeaturesEXT* = object | |
| 7764 sType*: VkStructureType | |
| 7765 pNext*: pointer | |
| 7766 depthClipEnable*: VkBool32 | |
| 7767 VkPipelineRasterizationDepthClipStateCreateInfoEXT* = object | |
| 7768 sType*: VkStructureType | |
| 7769 pNext*: pointer | |
| 7770 flags*: VkPipelineRasterizationDepthClipStateCreateFlagsEXT | |
| 7771 depthClipEnable*: VkBool32 | |
| 7772 VkPhysicalDeviceMemoryBudgetPropertiesEXT* = object | |
| 7773 sType*: VkStructureType | |
| 7774 pNext*: pointer | |
| 7775 heapBudget*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize] | |
| 7776 heapUsage*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize] | |
| 7777 VkPhysicalDeviceMemoryPriorityFeaturesEXT* = object | |
| 7778 sType*: VkStructureType | |
| 7779 pNext*: pointer | |
| 7780 memoryPriority*: VkBool32 | |
| 7781 VkMemoryPriorityAllocateInfoEXT* = object | |
| 7782 sType*: VkStructureType | |
| 7783 pNext*: pointer | |
| 7784 priority*: float32 | |
| 7785 VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* = object | |
| 7786 sType*: VkStructureType | |
| 7787 pNext*: pointer | |
| 7788 pageableDeviceLocalMemory*: VkBool32 | |
| 7789 VkPhysicalDeviceBufferDeviceAddressFeatures* = object | |
| 7790 sType*: VkStructureType | |
| 7791 pNext*: pointer | |
| 7792 bufferDeviceAddress*: VkBool32 | |
| 7793 bufferDeviceAddressCaptureReplay*: VkBool32 | |
| 7794 bufferDeviceAddressMultiDevice*: VkBool32 | |
| 7795 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR* = object | |
| 7796 VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* = object | |
| 7797 sType*: VkStructureType | |
| 7798 pNext*: pointer | |
| 7799 bufferDeviceAddress*: VkBool32 | |
| 7800 bufferDeviceAddressCaptureReplay*: VkBool32 | |
| 7801 bufferDeviceAddressMultiDevice*: VkBool32 | |
| 7802 VkPhysicalDeviceBufferAddressFeaturesEXT* = object | |
| 7803 VkBufferDeviceAddressInfo* = object | |
| 7804 sType*: VkStructureType | |
| 7805 pNext*: pointer | |
| 7806 buffer*: VkBuffer | |
| 7807 VkBufferDeviceAddressInfoKHR* = object | |
| 7808 VkBufferDeviceAddressInfoEXT* = object | |
| 7809 VkBufferOpaqueCaptureAddressCreateInfo* = object | |
| 7810 sType*: VkStructureType | |
| 7811 pNext*: pointer | |
| 7812 opaqueCaptureAddress*: uint64 | |
| 7813 VkBufferOpaqueCaptureAddressCreateInfoKHR* = object | |
| 7814 VkBufferDeviceAddressCreateInfoEXT* = object | |
| 7815 sType*: VkStructureType | |
| 7816 pNext*: pointer | |
| 7817 deviceAddress*: VkDeviceAddress | |
| 7818 VkPhysicalDeviceImageViewImageFormatInfoEXT* = object | |
| 7819 sType*: VkStructureType | |
| 7820 pNext*: pointer | |
| 7821 imageViewType*: VkImageViewType | |
| 7822 VkFilterCubicImageViewImageFormatPropertiesEXT* = object | |
| 7823 sType*: VkStructureType | |
| 7824 pNext*: pointer | |
| 7825 filterCubic*: VkBool32 | |
| 7826 filterCubicMinmax*: VkBool32 | |
| 7827 VkPhysicalDeviceImagelessFramebufferFeatures* = object | |
| 7828 sType*: VkStructureType | |
| 7829 pNext*: pointer | |
| 7830 imagelessFramebuffer*: VkBool32 | |
| 7831 VkPhysicalDeviceImagelessFramebufferFeaturesKHR* = object | |
| 7832 VkFramebufferAttachmentsCreateInfo* = object | |
| 7833 sType*: VkStructureType | |
| 7834 pNext*: pointer | |
| 7835 attachmentImageInfoCount*: uint32 | |
| 7836 pAttachmentImageInfos*: ptr VkFramebufferAttachmentImageInfo | |
| 7837 VkFramebufferAttachmentsCreateInfoKHR* = object | |
| 7838 VkFramebufferAttachmentImageInfo* = object | |
| 7839 sType*: VkStructureType | |
| 7840 pNext*: pointer | |
| 7841 flags*: VkImageCreateFlags | |
| 7842 usage*: VkImageUsageFlags | |
| 7843 width*: uint32 | |
| 7844 height*: uint32 | |
| 7845 layerCount*: uint32 | |
| 7846 viewFormatCount*: uint32 | |
| 7847 pViewFormats*: ptr VkFormat | |
| 7848 VkFramebufferAttachmentImageInfoKHR* = object | |
| 7849 VkRenderPassAttachmentBeginInfo* = object | |
| 7850 sType*: VkStructureType | |
| 7851 pNext*: pointer | |
| 7852 attachmentCount*: uint32 | |
| 7853 pAttachments*: ptr VkImageView | |
| 7854 VkRenderPassAttachmentBeginInfoKHR* = object | |
| 7855 VkPhysicalDeviceTextureCompressionASTCHDRFeatures* = object | |
| 7856 sType*: VkStructureType | |
| 7857 pNext*: pointer | |
| 7858 textureCompressionASTC_HDR*: VkBool32 | |
| 7859 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* = object | |
| 7860 VkPhysicalDeviceCooperativeMatrixFeaturesNV* = object | |
| 7861 sType*: VkStructureType | |
| 7862 pNext*: pointer | |
| 7863 cooperativeMatrix*: VkBool32 | |
| 7864 cooperativeMatrixRobustBufferAccess*: VkBool32 | |
| 7865 VkPhysicalDeviceCooperativeMatrixPropertiesNV* = object | |
| 7866 sType*: VkStructureType | |
| 7867 pNext*: pointer | |
| 7868 cooperativeMatrixSupportedStages*: VkShaderStageFlags | |
| 7869 VkCooperativeMatrixPropertiesNV* = object | |
| 7870 sType*: VkStructureType | |
| 7871 pNext*: pointer | |
| 7872 MSize*: uint32 | |
| 7873 NSize*: uint32 | |
| 7874 KSize*: uint32 | |
| 7875 AType*: VkComponentTypeNV | |
| 7876 BType*: VkComponentTypeNV | |
| 7877 CType*: VkComponentTypeNV | |
| 7878 DType*: VkComponentTypeNV | |
| 7879 scope*: VkScopeNV | |
| 7880 VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* = object | |
| 7881 sType*: VkStructureType | |
| 7882 pNext*: pointer | |
| 7883 ycbcrImageArrays*: VkBool32 | |
| 7884 VkImageViewHandleInfoNVX* = object | |
| 7885 sType*: VkStructureType | |
| 7886 pNext*: pointer | |
| 7887 imageView*: VkImageView | |
| 7888 descriptorType*: VkDescriptorType | |
| 7889 sampler*: VkSampler | |
| 7890 VkImageViewAddressPropertiesNVX* = object | |
| 7891 sType*: VkStructureType | |
| 7892 pNext*: pointer | |
| 7893 deviceAddress*: VkDeviceAddress | |
| 7894 size*: VkDeviceSize | |
| 7895 VkPipelineCreationFeedback* = object | |
| 7896 flags*: VkPipelineCreationFeedbackFlags | |
| 7897 duration*: uint64 | |
| 7898 VkPipelineCreationFeedbackEXT* = object | |
| 7899 VkPipelineCreationFeedbackCreateInfo* = object | |
| 7900 sType*: VkStructureType | |
| 7901 pNext*: pointer | |
| 7902 pPipelineCreationFeedback*: ptr VkPipelineCreationFeedback | |
| 7903 pipelineStageCreationFeedbackCount*: uint32 | |
| 7904 pPipelineStageCreationFeedbacks*: ptr VkPipelineCreationFeedback | |
| 7905 VkPipelineCreationFeedbackCreateInfoEXT* = object | |
| 7906 VkPhysicalDevicePresentBarrierFeaturesNV* = object | |
| 7907 sType*: VkStructureType | |
| 7908 pNext*: pointer | |
| 7909 presentBarrier*: VkBool32 | |
| 7910 VkSurfaceCapabilitiesPresentBarrierNV* = object | |
| 7911 sType*: VkStructureType | |
| 7912 pNext*: pointer | |
| 7913 presentBarrierSupported*: VkBool32 | |
| 7914 VkSwapchainPresentBarrierCreateInfoNV* = object | |
| 7915 sType*: VkStructureType | |
| 7916 pNext*: pointer | |
| 7917 presentBarrierEnable*: VkBool32 | |
| 7918 VkPhysicalDevicePerformanceQueryFeaturesKHR* = object | |
| 7919 sType*: VkStructureType | |
| 7920 pNext*: pointer | |
| 7921 performanceCounterQueryPools*: VkBool32 | |
| 7922 performanceCounterMultipleQueryPools*: VkBool32 | |
| 7923 VkPhysicalDevicePerformanceQueryPropertiesKHR* = object | |
| 7924 sType*: VkStructureType | |
| 7925 pNext*: pointer | |
| 7926 allowCommandBufferQueryCopies*: VkBool32 | |
| 7927 VkPerformanceCounterKHR* = object | |
| 7928 sType*: VkStructureType | |
| 7929 pNext*: pointer | |
| 7930 unit*: VkPerformanceCounterUnitKHR | |
| 7931 scope*: VkPerformanceCounterScopeKHR | |
| 7932 storage*: VkPerformanceCounterStorageKHR | |
| 7933 uuid*: array[VK_UUID_SIZE, uint8] | |
| 7934 VkPerformanceCounterDescriptionKHR* = object | |
| 7935 sType*: VkStructureType | |
| 7936 pNext*: pointer | |
| 7937 flags*: VkPerformanceCounterDescriptionFlagsKHR | |
| 7938 name*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 7939 category*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 7940 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 7941 VkQueryPoolPerformanceCreateInfoKHR* = object | |
| 7942 sType*: VkStructureType | |
| 7943 pNext*: pointer | |
| 7944 queueFamilyIndex*: uint32 | |
| 7945 counterIndexCount*: uint32 | |
| 7946 pCounterIndices*: ptr uint32 | |
| 7947 VkPerformanceCounterResultKHR* {.union.} = object | |
| 7948 int32*: int32 | |
| 7949 int64*: int64 | |
| 7950 uint32*: uint32 | |
| 7951 uint64*: uint64 | |
| 7952 float32*: float32 | |
| 7953 float64*: float64 | |
| 7954 VkAcquireProfilingLockInfoKHR* = object | |
| 7955 sType*: VkStructureType | |
| 7956 pNext*: pointer | |
| 7957 flags*: VkAcquireProfilingLockFlagsKHR | |
| 7958 timeout*: uint64 | |
| 7959 VkPerformanceQuerySubmitInfoKHR* = object | |
| 7960 sType*: VkStructureType | |
| 7961 pNext*: pointer | |
| 7962 counterPassIndex*: uint32 | |
| 7963 VkPerformanceQueryReservationInfoKHR* = object | |
| 7964 sType*: VkStructureType | |
| 7965 pNext*: pointer | |
| 7966 maxPerformanceQueriesPerPool*: uint32 | |
| 7967 VkHeadlessSurfaceCreateInfoEXT* = object | |
| 7968 sType*: VkStructureType | |
| 7969 pNext*: pointer | |
| 7970 flags*: VkHeadlessSurfaceCreateFlagsEXT | |
| 7971 VkPhysicalDeviceCoverageReductionModeFeaturesNV* = object | |
| 7972 sType*: VkStructureType | |
| 7973 pNext*: pointer | |
| 7974 coverageReductionMode*: VkBool32 | |
| 7975 VkPipelineCoverageReductionStateCreateInfoNV* = object | |
| 7976 sType*: VkStructureType | |
| 7977 pNext*: pointer | |
| 7978 flags*: VkPipelineCoverageReductionStateCreateFlagsNV | |
| 7979 coverageReductionMode*: VkCoverageReductionModeNV | |
| 7980 VkFramebufferMixedSamplesCombinationNV* = object | |
| 7981 sType*: VkStructureType | |
| 7982 pNext*: pointer | |
| 7983 coverageReductionMode*: VkCoverageReductionModeNV | |
| 7984 rasterizationSamples*: VkSampleCountFlagBits | |
| 7985 depthStencilSamples*: VkSampleCountFlags | |
| 7986 colorSamples*: VkSampleCountFlags | |
| 7987 VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* = object | |
| 7988 sType*: VkStructureType | |
| 7989 pNext*: pointer | |
| 7990 shaderIntegerFunctions2*: VkBool32 | |
| 7991 VkPerformanceValueDataINTEL* {.union.} = object | |
| 7992 value32*: uint32 | |
| 7993 value64*: uint64 | |
| 7994 valueFloat*: float32 | |
| 7995 valueBool*: VkBool32 | |
| 7996 valueString*: cstring | |
| 7997 VkPerformanceValueINTEL* = object | |
| 7998 thetype*: VkPerformanceValueTypeINTEL | |
| 7999 data*: VkPerformanceValueDataINTEL | |
| 8000 VkInitializePerformanceApiInfoINTEL* = object | |
| 8001 sType*: VkStructureType | |
| 8002 pNext*: pointer | |
| 8003 pUserData*: pointer | |
| 8004 VkQueryPoolPerformanceQueryCreateInfoINTEL* = object | |
| 8005 sType*: VkStructureType | |
| 8006 pNext*: pointer | |
| 8007 performanceCountersSampling*: VkQueryPoolSamplingModeINTEL | |
| 8008 VkQueryPoolCreateInfoINTEL* = object | |
| 8009 VkPerformanceMarkerInfoINTEL* = object | |
| 8010 sType*: VkStructureType | |
| 8011 pNext*: pointer | |
| 8012 marker*: uint64 | |
| 8013 VkPerformanceStreamMarkerInfoINTEL* = object | |
| 8014 sType*: VkStructureType | |
| 8015 pNext*: pointer | |
| 8016 marker*: uint32 | |
| 8017 VkPerformanceOverrideInfoINTEL* = object | |
| 8018 sType*: VkStructureType | |
| 8019 pNext*: pointer | |
| 8020 thetype*: VkPerformanceOverrideTypeINTEL | |
| 8021 enable*: VkBool32 | |
| 8022 parameter*: uint64 | |
| 8023 VkPerformanceConfigurationAcquireInfoINTEL* = object | |
| 8024 sType*: VkStructureType | |
| 8025 pNext*: pointer | |
| 8026 thetype*: VkPerformanceConfigurationTypeINTEL | |
| 8027 VkPhysicalDeviceShaderClockFeaturesKHR* = object | |
| 8028 sType*: VkStructureType | |
| 8029 pNext*: pointer | |
| 8030 shaderSubgroupClock*: VkBool32 | |
| 8031 shaderDeviceClock*: VkBool32 | |
| 8032 VkPhysicalDeviceIndexTypeUint8FeaturesEXT* = object | |
| 8033 sType*: VkStructureType | |
| 8034 pNext*: pointer | |
| 8035 indexTypeUint8*: VkBool32 | |
| 8036 VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* = object | |
| 8037 sType*: VkStructureType | |
| 8038 pNext*: pointer | |
| 8039 shaderSMCount*: uint32 | |
| 8040 shaderWarpsPerSM*: uint32 | |
| 8041 VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* = object | |
| 8042 sType*: VkStructureType | |
| 8043 pNext*: pointer | |
| 8044 shaderSMBuiltins*: VkBool32 | |
| 8045 VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* = object | |
| 8046 sType*: VkStructureType | |
| 8047 pNext*: pointer | |
| 8048 fragmentShaderSampleInterlock*: VkBool32 | |
| 8049 fragmentShaderPixelInterlock*: VkBool32 | |
| 8050 fragmentShaderShadingRateInterlock*: VkBool32 | |
| 8051 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* = object | |
| 8052 sType*: VkStructureType | |
| 8053 pNext*: pointer | |
| 8054 separateDepthStencilLayouts*: VkBool32 | |
| 8055 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR* = object | |
| 8056 VkAttachmentReferenceStencilLayout* = object | |
| 8057 sType*: VkStructureType | |
| 8058 pNext*: pointer | |
| 8059 stencilLayout*: VkImageLayout | |
| 8060 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* = object | |
| 8061 sType*: VkStructureType | |
| 8062 pNext*: pointer | |
| 8063 primitiveTopologyListRestart*: VkBool32 | |
| 8064 primitiveTopologyPatchListRestart*: VkBool32 | |
| 8065 VkAttachmentReferenceStencilLayoutKHR* = object | |
| 8066 VkAttachmentDescriptionStencilLayout* = object | |
| 8067 sType*: VkStructureType | |
| 8068 pNext*: pointer | |
| 8069 stencilInitialLayout*: VkImageLayout | |
| 8070 stencilFinalLayout*: VkImageLayout | |
| 8071 VkAttachmentDescriptionStencilLayoutKHR* = object | |
| 8072 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* = object | |
| 8073 sType*: VkStructureType | |
| 8074 pNext*: pointer | |
| 8075 pipelineExecutableInfo*: VkBool32 | |
| 8076 VkPipelineInfoKHR* = object | |
| 8077 sType*: VkStructureType | |
| 8078 pNext*: pointer | |
| 8079 pipeline*: VkPipeline | |
| 8080 VkPipelineInfoEXT* = object | |
| 8081 VkPipelineExecutablePropertiesKHR* = object | |
| 8082 sType*: VkStructureType | |
| 8083 pNext*: pointer | |
| 8084 stages*: VkShaderStageFlags | |
| 8085 name*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8086 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8087 subgroupSize*: uint32 | |
| 8088 VkPipelineExecutableInfoKHR* = object | |
| 8089 sType*: VkStructureType | |
| 8090 pNext*: pointer | |
| 8091 pipeline*: VkPipeline | |
| 8092 executableIndex*: uint32 | |
| 8093 VkPipelineExecutableStatisticValueKHR* {.union.} = object | |
| 8094 b32*: VkBool32 | |
| 8095 i64*: int64 | |
| 8096 u64*: uint64 | |
| 8097 f64*: float64 | |
| 8098 VkPipelineExecutableStatisticKHR* = object | |
| 8099 sType*: VkStructureType | |
| 8100 pNext*: pointer | |
| 8101 name*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8102 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8103 format*: VkPipelineExecutableStatisticFormatKHR | |
| 8104 value*: VkPipelineExecutableStatisticValueKHR | |
| 8105 VkPipelineExecutableInternalRepresentationKHR* = object | |
| 8106 sType*: VkStructureType | |
| 8107 pNext*: pointer | |
| 8108 name*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8109 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8110 isText*: VkBool32 | |
| 8111 dataSize*: csize_t | |
| 8112 pData*: pointer | |
| 8113 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* = object | |
| 8114 sType*: VkStructureType | |
| 8115 pNext*: pointer | |
| 8116 shaderDemoteToHelperInvocation*: VkBool32 | |
| 8117 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* = object | |
| 8118 VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* = object | |
| 8119 sType*: VkStructureType | |
| 8120 pNext*: pointer | |
| 8121 texelBufferAlignment*: VkBool32 | |
| 8122 VkPhysicalDeviceTexelBufferAlignmentProperties* = object | |
| 8123 sType*: VkStructureType | |
| 8124 pNext*: pointer | |
| 8125 storageTexelBufferOffsetAlignmentBytes*: VkDeviceSize | |
| 8126 storageTexelBufferOffsetSingleTexelAlignment*: VkBool32 | |
| 8127 uniformTexelBufferOffsetAlignmentBytes*: VkDeviceSize | |
| 8128 uniformTexelBufferOffsetSingleTexelAlignment*: VkBool32 | |
| 8129 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* = object | |
| 8130 VkPhysicalDeviceSubgroupSizeControlFeatures* = object | |
| 8131 sType*: VkStructureType | |
| 8132 pNext*: pointer | |
| 8133 subgroupSizeControl*: VkBool32 | |
| 8134 computeFullSubgroups*: VkBool32 | |
| 8135 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* = object | |
| 8136 VkPhysicalDeviceSubgroupSizeControlProperties* = object | |
| 8137 sType*: VkStructureType | |
| 8138 pNext*: pointer | |
| 8139 minSubgroupSize*: uint32 | |
| 8140 maxSubgroupSize*: uint32 | |
| 8141 maxComputeWorkgroupSubgroups*: uint32 | |
| 8142 requiredSubgroupSizeStages*: VkShaderStageFlags | |
| 8143 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* = object | |
| 8144 VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* = object | |
| 8145 sType*: VkStructureType | |
| 8146 pNext*: pointer | |
| 8147 requiredSubgroupSize*: uint32 | |
| 8148 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* = object | |
| 8149 VkSubpassShadingPipelineCreateInfoHUAWEI* = object | |
| 8150 sType*: VkStructureType | |
| 8151 pNext*: pointer | |
| 8152 renderPass*: VkRenderPass | |
| 8153 subpass*: uint32 | |
| 8154 VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* = object | |
| 8155 sType*: VkStructureType | |
| 8156 pNext*: pointer | |
| 8157 maxSubpassShadingWorkgroupSizeAspectRatio*: uint32 | |
| 8158 VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* = object | |
| 8159 sType*: VkStructureType | |
| 8160 pNext*: pointer | |
| 8161 maxWorkGroupCount*: array[3, uint32] | |
| 8162 maxWorkGroupSize*: array[3, uint32] | |
| 8163 maxOutputClusterCount*: uint32 | |
| 8164 VkMemoryOpaqueCaptureAddressAllocateInfo* = object | |
| 8165 sType*: VkStructureType | |
| 8166 pNext*: pointer | |
| 8167 opaqueCaptureAddress*: uint64 | |
| 8168 VkMemoryOpaqueCaptureAddressAllocateInfoKHR* = object | |
| 8169 VkDeviceMemoryOpaqueCaptureAddressInfo* = object | |
| 8170 sType*: VkStructureType | |
| 8171 pNext*: pointer | |
| 8172 memory*: VkDeviceMemory | |
| 8173 VkDeviceMemoryOpaqueCaptureAddressInfoKHR* = object | |
| 8174 VkPhysicalDeviceLineRasterizationFeaturesEXT* = object | |
| 8175 sType*: VkStructureType | |
| 8176 pNext*: pointer | |
| 8177 rectangularLines*: VkBool32 | |
| 8178 bresenhamLines*: VkBool32 | |
| 8179 smoothLines*: VkBool32 | |
| 8180 stippledRectangularLines*: VkBool32 | |
| 8181 stippledBresenhamLines*: VkBool32 | |
| 8182 stippledSmoothLines*: VkBool32 | |
| 8183 VkPhysicalDeviceLineRasterizationPropertiesEXT* = object | |
| 8184 sType*: VkStructureType | |
| 8185 pNext*: pointer | |
| 8186 lineSubPixelPrecisionBits*: uint32 | |
| 8187 VkPipelineRasterizationLineStateCreateInfoEXT* = object | |
| 8188 sType*: VkStructureType | |
| 8189 pNext*: pointer | |
| 8190 lineRasterizationMode*: VkLineRasterizationModeEXT | |
| 8191 stippledLineEnable*: VkBool32 | |
| 8192 lineStippleFactor*: uint32 | |
| 8193 lineStipplePattern*: uint16 | |
| 8194 VkPhysicalDevicePipelineCreationCacheControlFeatures* = object | |
| 8195 sType*: VkStructureType | |
| 8196 pNext*: pointer | |
| 8197 pipelineCreationCacheControl*: VkBool32 | |
| 8198 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* = object | |
| 8199 VkPhysicalDeviceVulkan11Features* = object | |
| 8200 sType*: VkStructureType | |
| 8201 pNext*: pointer | |
| 8202 storageBuffer16BitAccess*: VkBool32 | |
| 8203 uniformAndStorageBuffer16BitAccess*: VkBool32 | |
| 8204 storagePushConstant16*: VkBool32 | |
| 8205 storageInputOutput16*: VkBool32 | |
| 8206 multiview*: VkBool32 | |
| 8207 multiviewGeometryShader*: VkBool32 | |
| 8208 multiviewTessellationShader*: VkBool32 | |
| 8209 variablePointersStorageBuffer*: VkBool32 | |
| 8210 variablePointers*: VkBool32 | |
| 8211 protectedMemory*: VkBool32 | |
| 8212 samplerYcbcrConversion*: VkBool32 | |
| 8213 shaderDrawParameters*: VkBool32 | |
| 8214 VkPhysicalDeviceVulkan11Properties* = object | |
| 8215 sType*: VkStructureType | |
| 8216 pNext*: pointer | |
| 8217 deviceUUID*: array[VK_UUID_SIZE, uint8] | |
| 8218 driverUUID*: array[VK_UUID_SIZE, uint8] | |
| 8219 deviceLUID*: array[VK_LUID_SIZE, uint8] | |
| 8220 deviceNodeMask*: uint32 | |
| 8221 deviceLUIDValid*: VkBool32 | |
| 8222 subgroupSize*: uint32 | |
| 8223 subgroupSupportedStages*: VkShaderStageFlags | |
| 8224 subgroupSupportedOperations*: VkSubgroupFeatureFlags | |
| 8225 subgroupQuadOperationsInAllStages*: VkBool32 | |
| 8226 pointClippingBehavior*: VkPointClippingBehavior | |
| 8227 maxMultiviewViewCount*: uint32 | |
| 8228 maxMultiviewInstanceIndex*: uint32 | |
| 8229 protectedNoFault*: VkBool32 | |
| 8230 maxPerSetDescriptors*: uint32 | |
| 8231 maxMemoryAllocationSize*: VkDeviceSize | |
| 8232 VkPhysicalDeviceVulkan12Features* = object | |
| 8233 sType*: VkStructureType | |
| 8234 pNext*: pointer | |
| 8235 samplerMirrorClampToEdge*: VkBool32 | |
| 8236 drawIndirectCount*: VkBool32 | |
| 8237 storageBuffer8BitAccess*: VkBool32 | |
| 8238 uniformAndStorageBuffer8BitAccess*: VkBool32 | |
| 8239 storagePushConstant8*: VkBool32 | |
| 8240 shaderBufferInt64Atomics*: VkBool32 | |
| 8241 shaderSharedInt64Atomics*: VkBool32 | |
| 8242 shaderFloat16*: VkBool32 | |
| 8243 shaderInt8*: VkBool32 | |
| 8244 descriptorIndexing*: VkBool32 | |
| 8245 shaderInputAttachmentArrayDynamicIndexing*: VkBool32 | |
| 8246 shaderUniformTexelBufferArrayDynamicIndexing*: VkBool32 | |
| 8247 shaderStorageTexelBufferArrayDynamicIndexing*: VkBool32 | |
| 8248 shaderUniformBufferArrayNonUniformIndexing*: VkBool32 | |
| 8249 shaderSampledImageArrayNonUniformIndexing*: VkBool32 | |
| 8250 shaderStorageBufferArrayNonUniformIndexing*: VkBool32 | |
| 8251 shaderStorageImageArrayNonUniformIndexing*: VkBool32 | |
| 8252 shaderInputAttachmentArrayNonUniformIndexing*: VkBool32 | |
| 8253 shaderUniformTexelBufferArrayNonUniformIndexing*: VkBool32 | |
| 8254 shaderStorageTexelBufferArrayNonUniformIndexing*: VkBool32 | |
| 8255 descriptorBindingUniformBufferUpdateAfterBind*: VkBool32 | |
| 8256 descriptorBindingSampledImageUpdateAfterBind*: VkBool32 | |
| 8257 descriptorBindingStorageImageUpdateAfterBind*: VkBool32 | |
| 8258 descriptorBindingStorageBufferUpdateAfterBind*: VkBool32 | |
| 8259 descriptorBindingUniformTexelBufferUpdateAfterBind*: VkBool32 | |
| 8260 descriptorBindingStorageTexelBufferUpdateAfterBind*: VkBool32 | |
| 8261 descriptorBindingUpdateUnusedWhilePending*: VkBool32 | |
| 8262 descriptorBindingPartiallyBound*: VkBool32 | |
| 8263 descriptorBindingVariableDescriptorCount*: VkBool32 | |
| 8264 runtimeDescriptorArray*: VkBool32 | |
| 8265 samplerFilterMinmax*: VkBool32 | |
| 8266 scalarBlockLayout*: VkBool32 | |
| 8267 imagelessFramebuffer*: VkBool32 | |
| 8268 uniformBufferStandardLayout*: VkBool32 | |
| 8269 shaderSubgroupExtendedTypes*: VkBool32 | |
| 8270 separateDepthStencilLayouts*: VkBool32 | |
| 8271 hostQueryReset*: VkBool32 | |
| 8272 timelineSemaphore*: VkBool32 | |
| 8273 bufferDeviceAddress*: VkBool32 | |
| 8274 bufferDeviceAddressCaptureReplay*: VkBool32 | |
| 8275 bufferDeviceAddressMultiDevice*: VkBool32 | |
| 8276 vulkanMemoryModel*: VkBool32 | |
| 8277 vulkanMemoryModelDeviceScope*: VkBool32 | |
| 8278 vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32 | |
| 8279 shaderOutputViewportIndex*: VkBool32 | |
| 8280 shaderOutputLayer*: VkBool32 | |
| 8281 subgroupBroadcastDynamicId*: VkBool32 | |
| 8282 VkPhysicalDeviceVulkan12Properties* = object | |
| 8283 sType*: VkStructureType | |
| 8284 pNext*: pointer | |
| 8285 driverID*: VkDriverId | |
| 8286 driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char] | |
| 8287 driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char] | |
| 8288 conformanceVersion*: VkConformanceVersion | |
| 8289 denormBehaviorIndependence*: VkShaderFloatControlsIndependence | |
| 8290 roundingModeIndependence*: VkShaderFloatControlsIndependence | |
| 8291 shaderSignedZeroInfNanPreserveFloat16*: VkBool32 | |
| 8292 shaderSignedZeroInfNanPreserveFloat32*: VkBool32 | |
| 8293 shaderSignedZeroInfNanPreserveFloat64*: VkBool32 | |
| 8294 shaderDenormPreserveFloat16*: VkBool32 | |
| 8295 shaderDenormPreserveFloat32*: VkBool32 | |
| 8296 shaderDenormPreserveFloat64*: VkBool32 | |
| 8297 shaderDenormFlushToZeroFloat16*: VkBool32 | |
| 8298 shaderDenormFlushToZeroFloat32*: VkBool32 | |
| 8299 shaderDenormFlushToZeroFloat64*: VkBool32 | |
| 8300 shaderRoundingModeRTEFloat16*: VkBool32 | |
| 8301 shaderRoundingModeRTEFloat32*: VkBool32 | |
| 8302 shaderRoundingModeRTEFloat64*: VkBool32 | |
| 8303 shaderRoundingModeRTZFloat16*: VkBool32 | |
| 8304 shaderRoundingModeRTZFloat32*: VkBool32 | |
| 8305 shaderRoundingModeRTZFloat64*: VkBool32 | |
| 8306 maxUpdateAfterBindDescriptorsInAllPools*: uint32 | |
| 8307 shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32 | |
| 8308 shaderSampledImageArrayNonUniformIndexingNative*: VkBool32 | |
| 8309 shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32 | |
| 8310 shaderStorageImageArrayNonUniformIndexingNative*: VkBool32 | |
| 8311 shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32 | |
| 8312 robustBufferAccessUpdateAfterBind*: VkBool32 | |
| 8313 quadDivergentImplicitLod*: VkBool32 | |
| 8314 maxPerStageDescriptorUpdateAfterBindSamplers*: uint32 | |
| 8315 maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32 | |
| 8316 maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32 | |
| 8317 maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32 | |
| 8318 maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32 | |
| 8319 maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32 | |
| 8320 maxPerStageUpdateAfterBindResources*: uint32 | |
| 8321 maxDescriptorSetUpdateAfterBindSamplers*: uint32 | |
| 8322 maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32 | |
| 8323 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32 | |
| 8324 maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32 | |
| 8325 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32 | |
| 8326 maxDescriptorSetUpdateAfterBindSampledImages*: uint32 | |
| 8327 maxDescriptorSetUpdateAfterBindStorageImages*: uint32 | |
| 8328 maxDescriptorSetUpdateAfterBindInputAttachments*: uint32 | |
| 8329 supportedDepthResolveModes*: VkResolveModeFlags | |
| 8330 supportedStencilResolveModes*: VkResolveModeFlags | |
| 8331 independentResolveNone*: VkBool32 | |
| 8332 independentResolve*: VkBool32 | |
| 8333 filterMinmaxSingleComponentFormats*: VkBool32 | |
| 8334 filterMinmaxImageComponentMapping*: VkBool32 | |
| 8335 maxTimelineSemaphoreValueDifference*: uint64 | |
| 8336 framebufferIntegerColorSampleCounts*: VkSampleCountFlags | |
| 8337 VkPhysicalDeviceVulkan13Features* = object | |
| 8338 sType*: VkStructureType | |
| 8339 pNext*: pointer | |
| 8340 robustImageAccess*: VkBool32 | |
| 8341 inlineUniformBlock*: VkBool32 | |
| 8342 descriptorBindingInlineUniformBlockUpdateAfterBind*: VkBool32 | |
| 8343 pipelineCreationCacheControl*: VkBool32 | |
| 8344 privateData*: VkBool32 | |
| 8345 shaderDemoteToHelperInvocation*: VkBool32 | |
| 8346 shaderTerminateInvocation*: VkBool32 | |
| 8347 subgroupSizeControl*: VkBool32 | |
| 8348 computeFullSubgroups*: VkBool32 | |
| 8349 synchronization2*: VkBool32 | |
| 8350 textureCompressionASTC_HDR*: VkBool32 | |
| 8351 shaderZeroInitializeWorkgroupMemory*: VkBool32 | |
| 8352 dynamicRendering*: VkBool32 | |
| 8353 shaderIntegerDotProduct*: VkBool32 | |
| 8354 maintenance4*: VkBool32 | |
| 8355 VkPhysicalDeviceVulkan13Properties* = object | |
| 8356 sType*: VkStructureType | |
| 8357 pNext*: pointer | |
| 8358 minSubgroupSize*: uint32 | |
| 8359 maxSubgroupSize*: uint32 | |
| 8360 maxComputeWorkgroupSubgroups*: uint32 | |
| 8361 requiredSubgroupSizeStages*: VkShaderStageFlags | |
| 8362 maxInlineUniformBlockSize*: uint32 | |
| 8363 maxPerStageDescriptorInlineUniformBlocks*: uint32 | |
| 8364 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks*: uint32 | |
| 8365 maxDescriptorSetInlineUniformBlocks*: uint32 | |
| 8366 maxDescriptorSetUpdateAfterBindInlineUniformBlocks*: uint32 | |
| 8367 maxInlineUniformTotalSize*: uint32 | |
| 8368 integerDotProduct8BitUnsignedAccelerated*: VkBool32 | |
| 8369 integerDotProduct8BitSignedAccelerated*: VkBool32 | |
| 8370 integerDotProduct8BitMixedSignednessAccelerated*: VkBool32 | |
| 8371 integerDotProduct4x8BitPackedUnsignedAccelerated*: VkBool32 | |
| 8372 integerDotProduct4x8BitPackedSignedAccelerated*: VkBool32 | |
| 8373 integerDotProduct4x8BitPackedMixedSignednessAccelerated*: VkBool32 | |
| 8374 integerDotProduct16BitUnsignedAccelerated*: VkBool32 | |
| 8375 integerDotProduct16BitSignedAccelerated*: VkBool32 | |
| 8376 integerDotProduct16BitMixedSignednessAccelerated*: VkBool32 | |
| 8377 integerDotProduct32BitUnsignedAccelerated*: VkBool32 | |
| 8378 integerDotProduct32BitSignedAccelerated*: VkBool32 | |
| 8379 integerDotProduct32BitMixedSignednessAccelerated*: VkBool32 | |
| 8380 integerDotProduct64BitUnsignedAccelerated*: VkBool32 | |
| 8381 integerDotProduct64BitSignedAccelerated*: VkBool32 | |
| 8382 integerDotProduct64BitMixedSignednessAccelerated*: VkBool32 | |
| 8383 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated*: VkBool32 | |
| 8384 integerDotProductAccumulatingSaturating8BitSignedAccelerated*: VkBool32 | |
| 8385 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated*: VkBool32 | |
| 8386 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated*: VkBool32 | |
| 8387 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated*: VkBool32 | |
| 8388 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated*: VkBool32 | |
| 8389 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated*: VkBool32 | |
| 8390 integerDotProductAccumulatingSaturating16BitSignedAccelerated*: VkBool32 | |
| 8391 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated*: VkBool32 | |
| 8392 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated*: VkBool32 | |
| 8393 integerDotProductAccumulatingSaturating32BitSignedAccelerated*: VkBool32 | |
| 8394 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated*: VkBool32 | |
| 8395 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated*: VkBool32 | |
| 8396 integerDotProductAccumulatingSaturating64BitSignedAccelerated*: VkBool32 | |
| 8397 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated*: VkBool32 | |
| 8398 storageTexelBufferOffsetAlignmentBytes*: VkDeviceSize | |
| 8399 storageTexelBufferOffsetSingleTexelAlignment*: VkBool32 | |
| 8400 uniformTexelBufferOffsetAlignmentBytes*: VkDeviceSize | |
| 8401 uniformTexelBufferOffsetSingleTexelAlignment*: VkBool32 | |
| 8402 maxBufferSize*: VkDeviceSize | |
| 8403 VkPipelineCompilerControlCreateInfoAMD* = object | |
| 8404 sType*: VkStructureType | |
| 8405 pNext*: pointer | |
| 8406 compilerControlFlags*: VkPipelineCompilerControlFlagsAMD | |
| 8407 VkPhysicalDeviceCoherentMemoryFeaturesAMD* = object | |
| 8408 sType*: VkStructureType | |
| 8409 pNext*: pointer | |
| 8410 deviceCoherentMemory*: VkBool32 | |
| 8411 VkFaultData* = object | |
| 8412 sType*: VkStructureType | |
| 8413 pNext*: pointer | |
| 8414 faultLevel*: VkFaultLevel | |
| 8415 faultType*: VkFaultType | |
| 8416 VkFaultCallbackInfo* = object | |
| 8417 sType*: VkStructureType | |
| 8418 pNext*: pointer | |
| 8419 faultCount*: uint32 | |
| 8420 pFaults*: ptr VkFaultData | |
| 8421 pfnFaultCallback*: PFN_vkFaultCallbackFunction | |
| 8422 VkPhysicalDeviceToolProperties* = object | |
| 8423 sType*: VkStructureType | |
| 8424 pNext*: pointer | |
| 8425 name*: array[VK_MAX_EXTENSION_NAME_SIZE, char] | |
| 8426 version*: array[VK_MAX_EXTENSION_NAME_SIZE, char] | |
| 8427 purposes*: VkToolPurposeFlags | |
| 8428 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 8429 layer*: array[VK_MAX_EXTENSION_NAME_SIZE, char] | |
| 8430 VkPhysicalDeviceToolPropertiesEXT* = object | |
| 8431 VkSamplerCustomBorderColorCreateInfoEXT* = object | |
| 8432 sType*: VkStructureType | |
| 8433 pNext*: pointer | |
| 8434 customBorderColor*: VkClearColorValue | |
| 8435 format*: VkFormat | |
| 8436 VkPhysicalDeviceCustomBorderColorPropertiesEXT* = object | |
| 8437 sType*: VkStructureType | |
| 8438 pNext*: pointer | |
| 8439 maxCustomBorderColorSamplers*: uint32 | |
| 8440 VkPhysicalDeviceCustomBorderColorFeaturesEXT* = object | |
| 8441 sType*: VkStructureType | |
| 8442 pNext*: pointer | |
| 8443 customBorderColors*: VkBool32 | |
| 8444 customBorderColorWithoutFormat*: VkBool32 | |
| 8445 VkSamplerBorderColorComponentMappingCreateInfoEXT* = object | |
| 8446 sType*: VkStructureType | |
| 8447 pNext*: pointer | |
| 8448 components*: VkComponentMapping | |
| 8449 srgb*: VkBool32 | |
| 8450 VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* = object | |
| 8451 sType*: VkStructureType | |
| 8452 pNext*: pointer | |
| 8453 borderColorSwizzle*: VkBool32 | |
| 8454 borderColorSwizzleFromImage*: VkBool32 | |
| 8455 VkDeviceOrHostAddressKHR* {.union.} = object | |
| 8456 deviceAddress*: VkDeviceAddress | |
| 8457 hostAddress*: pointer | |
| 8458 VkDeviceOrHostAddressConstKHR* {.union.} = object | |
| 8459 deviceAddress*: VkDeviceAddress | |
| 8460 hostAddress*: pointer | |
| 8461 VkAccelerationStructureGeometryTrianglesDataKHR* = object | |
| 8462 sType*: VkStructureType | |
| 8463 pNext*: pointer | |
| 8464 vertexFormat*: VkFormat | |
| 8465 vertexData*: VkDeviceOrHostAddressConstKHR | |
| 8466 vertexStride*: VkDeviceSize | |
| 8467 maxVertex*: uint32 | |
| 8468 indexType*: VkIndexType | |
| 8469 indexData*: VkDeviceOrHostAddressConstKHR | |
| 8470 transformData*: VkDeviceOrHostAddressConstKHR | |
| 8471 VkAccelerationStructureGeometryAabbsDataKHR* = object | |
| 8472 sType*: VkStructureType | |
| 8473 pNext*: pointer | |
| 8474 data*: VkDeviceOrHostAddressConstKHR | |
| 8475 stride*: VkDeviceSize | |
| 8476 VkAccelerationStructureGeometryInstancesDataKHR* = object | |
| 8477 sType*: VkStructureType | |
| 8478 pNext*: pointer | |
| 8479 arrayOfPointers*: VkBool32 | |
| 8480 data*: VkDeviceOrHostAddressConstKHR | |
| 8481 VkAccelerationStructureGeometryDataKHR* {.union.} = object | |
| 8482 triangles*: VkAccelerationStructureGeometryTrianglesDataKHR | |
| 8483 aabbs*: VkAccelerationStructureGeometryAabbsDataKHR | |
| 8484 instances*: VkAccelerationStructureGeometryInstancesDataKHR | |
| 8485 VkAccelerationStructureGeometryKHR* = object | |
| 8486 sType*: VkStructureType | |
| 8487 pNext*: pointer | |
| 8488 geometryType*: VkGeometryTypeKHR | |
| 8489 geometry*: VkAccelerationStructureGeometryDataKHR | |
| 8490 flags*: VkGeometryFlagsKHR | |
| 8491 VkAccelerationStructureBuildGeometryInfoKHR* = object | |
| 8492 sType*: VkStructureType | |
| 8493 pNext*: pointer | |
| 8494 thetype*: VkAccelerationStructureTypeKHR | |
| 8495 flags*: VkBuildAccelerationStructureFlagsKHR | |
| 8496 mode*: VkBuildAccelerationStructureModeKHR | |
| 8497 srcAccelerationStructure*: VkAccelerationStructureKHR | |
| 8498 dstAccelerationStructure*: VkAccelerationStructureKHR | |
| 8499 geometryCount*: uint32 | |
| 8500 pGeometries*: ptr VkAccelerationStructureGeometryKHR | |
| 8501 ppGeometries*: ptr ptr VkAccelerationStructureGeometryKHR | |
| 8502 scratchData*: VkDeviceOrHostAddressKHR | |
| 8503 VkAccelerationStructureBuildRangeInfoKHR* = object | |
| 8504 primitiveCount*: uint32 | |
| 8505 primitiveOffset*: uint32 | |
| 8506 firstVertex*: uint32 | |
| 8507 transformOffset*: uint32 | |
| 8508 VkAccelerationStructureCreateInfoKHR* = object | |
| 8509 sType*: VkStructureType | |
| 8510 pNext*: pointer | |
| 8511 createFlags*: VkAccelerationStructureCreateFlagsKHR | |
| 8512 buffer*: VkBuffer | |
| 8513 offset*: VkDeviceSize | |
| 8514 size*: VkDeviceSize | |
| 8515 thetype*: VkAccelerationStructureTypeKHR | |
| 8516 deviceAddress*: VkDeviceAddress | |
| 8517 VkAabbPositionsKHR* = object | |
| 8518 minX*: float32 | |
| 8519 minY*: float32 | |
| 8520 minZ*: float32 | |
| 8521 maxX*: float32 | |
| 8522 maxY*: float32 | |
| 8523 maxZ*: float32 | |
| 8524 VkAabbPositionsNV* = object | |
| 8525 VkTransformMatrixKHR* = object | |
| 8526 matrix*: array[3*4, float32] | |
| 8527 VkTransformMatrixNV* = object | |
| 8528 VkAccelerationStructureInstanceKHR* = object | |
| 8529 transform*: VkTransformMatrixKHR | |
| 8530 instanceCustomIndex*: uint32 | |
| 8531 mask*: uint32 | |
| 8532 instanceShaderBindingTableRecordOffset*: uint32 | |
| 8533 flags*: VkGeometryInstanceFlagsKHR | |
| 8534 accelerationStructureReference*: uint64 | |
| 8535 VkAccelerationStructureInstanceNV* = object | |
| 8536 VkAccelerationStructureDeviceAddressInfoKHR* = object | |
| 8537 sType*: VkStructureType | |
| 8538 pNext*: pointer | |
| 8539 accelerationStructure*: VkAccelerationStructureKHR | |
| 8540 VkAccelerationStructureVersionInfoKHR* = object | |
| 8541 sType*: VkStructureType | |
| 8542 pNext*: pointer | |
| 8543 pVersionData*: ptr uint8 | |
| 8544 VkCopyAccelerationStructureInfoKHR* = object | |
| 8545 sType*: VkStructureType | |
| 8546 pNext*: pointer | |
| 8547 src*: VkAccelerationStructureKHR | |
| 8548 dst*: VkAccelerationStructureKHR | |
| 8549 mode*: VkCopyAccelerationStructureModeKHR | |
| 8550 VkCopyAccelerationStructureToMemoryInfoKHR* = object | |
| 8551 sType*: VkStructureType | |
| 8552 pNext*: pointer | |
| 8553 src*: VkAccelerationStructureKHR | |
| 8554 dst*: VkDeviceOrHostAddressKHR | |
| 8555 mode*: VkCopyAccelerationStructureModeKHR | |
| 8556 VkCopyMemoryToAccelerationStructureInfoKHR* = object | |
| 8557 sType*: VkStructureType | |
| 8558 pNext*: pointer | |
| 8559 src*: VkDeviceOrHostAddressConstKHR | |
| 8560 dst*: VkAccelerationStructureKHR | |
| 8561 mode*: VkCopyAccelerationStructureModeKHR | |
| 8562 VkRayTracingPipelineInterfaceCreateInfoKHR* = object | |
| 8563 sType*: VkStructureType | |
| 8564 pNext*: pointer | |
| 8565 maxPipelineRayPayloadSize*: uint32 | |
| 8566 maxPipelineRayHitAttributeSize*: uint32 | |
| 8567 VkPipelineLibraryCreateInfoKHR* = object | |
| 8568 sType*: VkStructureType | |
| 8569 pNext*: pointer | |
| 8570 libraryCount*: uint32 | |
| 8571 pLibraries*: ptr VkPipeline | |
| 8572 VkRefreshObjectKHR* = object | |
| 8573 objectType*: VkObjectType | |
| 8574 objectHandle*: uint64 | |
| 8575 flags*: VkRefreshObjectFlagsKHR | |
| 8576 VkRefreshObjectListKHR* = object | |
| 8577 sType*: VkStructureType | |
| 8578 pNext*: pointer | |
| 8579 objectCount*: uint32 | |
| 8580 pObjects*: ptr VkRefreshObjectKHR | |
| 8581 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* = object | |
| 8582 sType*: VkStructureType | |
| 8583 pNext*: pointer | |
| 8584 extendedDynamicState*: VkBool32 | |
| 8585 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* = object | |
| 8586 sType*: VkStructureType | |
| 8587 pNext*: pointer | |
| 8588 extendedDynamicState2*: VkBool32 | |
| 8589 extendedDynamicState2LogicOp*: VkBool32 | |
| 8590 extendedDynamicState2PatchControlPoints*: VkBool32 | |
| 8591 VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* = object | |
| 8592 sType*: VkStructureType | |
| 8593 pNext*: pointer | |
| 8594 extendedDynamicState3TessellationDomainOrigin*: VkBool32 | |
| 8595 extendedDynamicState3DepthClampEnable*: VkBool32 | |
| 8596 extendedDynamicState3PolygonMode*: VkBool32 | |
| 8597 extendedDynamicState3RasterizationSamples*: VkBool32 | |
| 8598 extendedDynamicState3SampleMask*: VkBool32 | |
| 8599 extendedDynamicState3AlphaToCoverageEnable*: VkBool32 | |
| 8600 extendedDynamicState3AlphaToOneEnable*: VkBool32 | |
| 8601 extendedDynamicState3LogicOpEnable*: VkBool32 | |
| 8602 extendedDynamicState3ColorBlendEnable*: VkBool32 | |
| 8603 extendedDynamicState3ColorBlendEquation*: VkBool32 | |
| 8604 extendedDynamicState3ColorWriteMask*: VkBool32 | |
| 8605 extendedDynamicState3RasterizationStream*: VkBool32 | |
| 8606 extendedDynamicState3ConservativeRasterizationMode*: VkBool32 | |
| 8607 extendedDynamicState3ExtraPrimitiveOverestimationSize*: VkBool32 | |
| 8608 extendedDynamicState3DepthClipEnable*: VkBool32 | |
| 8609 extendedDynamicState3SampleLocationsEnable*: VkBool32 | |
| 8610 extendedDynamicState3ColorBlendAdvanced*: VkBool32 | |
| 8611 extendedDynamicState3ProvokingVertexMode*: VkBool32 | |
| 8612 extendedDynamicState3LineRasterizationMode*: VkBool32 | |
| 8613 extendedDynamicState3LineStippleEnable*: VkBool32 | |
| 8614 extendedDynamicState3DepthClipNegativeOneToOne*: VkBool32 | |
| 8615 extendedDynamicState3ViewportWScalingEnable*: VkBool32 | |
| 8616 extendedDynamicState3ViewportSwizzle*: VkBool32 | |
| 8617 extendedDynamicState3CoverageToColorEnable*: VkBool32 | |
| 8618 extendedDynamicState3CoverageToColorLocation*: VkBool32 | |
| 8619 extendedDynamicState3CoverageModulationMode*: VkBool32 | |
| 8620 extendedDynamicState3CoverageModulationTableEnable*: VkBool32 | |
| 8621 extendedDynamicState3CoverageModulationTable*: VkBool32 | |
| 8622 extendedDynamicState3CoverageReductionMode*: VkBool32 | |
| 8623 extendedDynamicState3RepresentativeFragmentTestEnable*: VkBool32 | |
| 8624 extendedDynamicState3ShadingRateImageEnable*: VkBool32 | |
| 8625 VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* = object | |
| 8626 sType*: VkStructureType | |
| 8627 pNext*: pointer | |
| 8628 dynamicPrimitiveTopologyUnrestricted*: VkBool32 | |
| 8629 VkColorBlendEquationEXT* = object | |
| 8630 srcColorBlendFactor*: VkBlendFactor | |
| 8631 dstColorBlendFactor*: VkBlendFactor | |
| 8632 colorBlendOp*: VkBlendOp | |
| 8633 srcAlphaBlendFactor*: VkBlendFactor | |
| 8634 dstAlphaBlendFactor*: VkBlendFactor | |
| 8635 alphaBlendOp*: VkBlendOp | |
| 8636 VkColorBlendAdvancedEXT* = object | |
| 8637 advancedBlendOp*: VkBlendOp | |
| 8638 srcPremultiplied*: VkBool32 | |
| 8639 dstPremultiplied*: VkBool32 | |
| 8640 blendOverlap*: VkBlendOverlapEXT | |
| 8641 clampResults*: VkBool32 | |
| 8642 VkRenderPassTransformBeginInfoQCOM* = object | |
| 8643 sType*: VkStructureType | |
| 8644 pNext*: pointer | |
| 8645 transform*: VkSurfaceTransformFlagBitsKHR | |
| 8646 VkCopyCommandTransformInfoQCOM* = object | |
| 8647 sType*: VkStructureType | |
| 8648 pNext*: pointer | |
| 8649 transform*: VkSurfaceTransformFlagBitsKHR | |
| 8650 VkCommandBufferInheritanceRenderPassTransformInfoQCOM* = object | |
| 8651 sType*: VkStructureType | |
| 8652 pNext*: pointer | |
| 8653 transform*: VkSurfaceTransformFlagBitsKHR | |
| 8654 renderArea*: VkRect2D | |
| 8655 VkPhysicalDeviceDiagnosticsConfigFeaturesNV* = object | |
| 8656 sType*: VkStructureType | |
| 8657 pNext*: pointer | |
| 8658 diagnosticsConfig*: VkBool32 | |
| 8659 VkDeviceDiagnosticsConfigCreateInfoNV* = object | |
| 8660 sType*: VkStructureType | |
| 8661 pNext*: pointer | |
| 8662 flags*: VkDeviceDiagnosticsConfigFlagsNV | |
| 8663 VkPipelineOfflineCreateInfo* = object | |
| 8664 sType*: VkStructureType | |
| 8665 pNext*: pointer | |
| 8666 pipelineIdentifier*: array[VK_UUID_SIZE, uint8] | |
| 8667 matchControl*: VkPipelineMatchControl | |
| 8668 poolEntrySize*: VkDeviceSize | |
| 8669 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* = object | |
| 8670 sType*: VkStructureType | |
| 8671 pNext*: pointer | |
| 8672 shaderZeroInitializeWorkgroupMemory*: VkBool32 | |
| 8673 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* = object | |
| 8674 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* = object | |
| 8675 sType*: VkStructureType | |
| 8676 pNext*: pointer | |
| 8677 shaderSubgroupUniformControlFlow*: VkBool32 | |
| 8678 VkPhysicalDeviceRobustness2FeaturesEXT* = object | |
| 8679 sType*: VkStructureType | |
| 8680 pNext*: pointer | |
| 8681 robustBufferAccess2*: VkBool32 | |
| 8682 robustImageAccess2*: VkBool32 | |
| 8683 nullDescriptor*: VkBool32 | |
| 8684 VkPhysicalDeviceRobustness2PropertiesEXT* = object | |
| 8685 sType*: VkStructureType | |
| 8686 pNext*: pointer | |
| 8687 robustStorageBufferAccessSizeAlignment*: VkDeviceSize | |
| 8688 robustUniformBufferAccessSizeAlignment*: VkDeviceSize | |
| 8689 VkPhysicalDeviceImageRobustnessFeatures* = object | |
| 8690 sType*: VkStructureType | |
| 8691 pNext*: pointer | |
| 8692 robustImageAccess*: VkBool32 | |
| 8693 VkPhysicalDeviceImageRobustnessFeaturesEXT* = object | |
| 8694 VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* = object | |
| 8695 sType*: VkStructureType | |
| 8696 pNext*: pointer | |
| 8697 workgroupMemoryExplicitLayout*: VkBool32 | |
| 8698 workgroupMemoryExplicitLayoutScalarBlockLayout*: VkBool32 | |
| 8699 workgroupMemoryExplicitLayout8BitAccess*: VkBool32 | |
| 8700 workgroupMemoryExplicitLayout16BitAccess*: VkBool32 | |
| 8701 VkPhysicalDevice4444FormatsFeaturesEXT* = object | |
| 8702 sType*: VkStructureType | |
| 8703 pNext*: pointer | |
| 8704 formatA4R4G4B4*: VkBool32 | |
| 8705 formatA4B4G4R4*: VkBool32 | |
| 8706 VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* = object | |
| 8707 sType*: VkStructureType | |
| 8708 pNext*: pointer | |
| 8709 subpassShading*: VkBool32 | |
| 8710 VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* = object | |
| 8711 sType*: VkStructureType | |
| 8712 pNext*: pointer | |
| 8713 clustercullingShader*: VkBool32 | |
| 8714 multiviewClusterCullingShader*: VkBool32 | |
| 8715 VkBufferCopy2* = object | |
| 8716 sType*: VkStructureType | |
| 8717 pNext*: pointer | |
| 8718 srcOffset*: VkDeviceSize | |
| 8719 dstOffset*: VkDeviceSize | |
| 8720 size*: VkDeviceSize | |
| 8721 VkBufferCopy2KHR* = object | |
| 8722 VkImageCopy2* = object | |
| 8723 sType*: VkStructureType | |
| 8724 pNext*: pointer | |
| 8725 srcSubresource*: VkImageSubresourceLayers | |
| 8726 srcOffset*: VkOffset3D | |
| 8727 dstSubresource*: VkImageSubresourceLayers | |
| 8728 dstOffset*: VkOffset3D | |
| 8729 extent*: VkExtent3D | |
| 8730 VkImageCopy2KHR* = object | |
| 8731 VkImageBlit2* = object | |
| 8732 sType*: VkStructureType | |
| 8733 pNext*: pointer | |
| 8734 srcSubresource*: VkImageSubresourceLayers | |
| 8735 srcOffsets*: array[2, VkOffset3D] | |
| 8736 dstSubresource*: VkImageSubresourceLayers | |
| 8737 dstOffsets*: array[2, VkOffset3D] | |
| 8738 VkImageBlit2KHR* = object | |
| 8739 VkBufferImageCopy2* = object | |
| 8740 sType*: VkStructureType | |
| 8741 pNext*: pointer | |
| 8742 bufferOffset*: VkDeviceSize | |
| 8743 bufferRowLength*: uint32 | |
| 8744 bufferImageHeight*: uint32 | |
| 8745 imageSubresource*: VkImageSubresourceLayers | |
| 8746 imageOffset*: VkOffset3D | |
| 8747 imageExtent*: VkExtent3D | |
| 8748 VkBufferImageCopy2KHR* = object | |
| 8749 VkImageResolve2* = object | |
| 8750 sType*: VkStructureType | |
| 8751 pNext*: pointer | |
| 8752 srcSubresource*: VkImageSubresourceLayers | |
| 8753 srcOffset*: VkOffset3D | |
| 8754 dstSubresource*: VkImageSubresourceLayers | |
| 8755 dstOffset*: VkOffset3D | |
| 8756 extent*: VkExtent3D | |
| 8757 VkImageResolve2KHR* = object | |
| 8758 VkCopyBufferInfo2* = object | |
| 8759 sType*: VkStructureType | |
| 8760 pNext*: pointer | |
| 8761 srcBuffer*: VkBuffer | |
| 8762 dstBuffer*: VkBuffer | |
| 8763 regionCount*: uint32 | |
| 8764 pRegions*: ptr VkBufferCopy2 | |
| 8765 VkCopyBufferInfo2KHR* = object | |
| 8766 VkCopyImageInfo2* = object | |
| 8767 sType*: VkStructureType | |
| 8768 pNext*: pointer | |
| 8769 srcImage*: VkImage | |
| 8770 srcImageLayout*: VkImageLayout | |
| 8771 dstImage*: VkImage | |
| 8772 dstImageLayout*: VkImageLayout | |
| 8773 regionCount*: uint32 | |
| 8774 pRegions*: ptr VkImageCopy2 | |
| 8775 VkCopyImageInfo2KHR* = object | |
| 8776 VkBlitImageInfo2* = object | |
| 8777 sType*: VkStructureType | |
| 8778 pNext*: pointer | |
| 8779 srcImage*: VkImage | |
| 8780 srcImageLayout*: VkImageLayout | |
| 8781 dstImage*: VkImage | |
| 8782 dstImageLayout*: VkImageLayout | |
| 8783 regionCount*: uint32 | |
| 8784 pRegions*: ptr VkImageBlit2 | |
| 8785 filter*: VkFilter | |
| 8786 VkBlitImageInfo2KHR* = object | |
| 8787 VkCopyBufferToImageInfo2* = object | |
| 8788 sType*: VkStructureType | |
| 8789 pNext*: pointer | |
| 8790 srcBuffer*: VkBuffer | |
| 8791 dstImage*: VkImage | |
| 8792 dstImageLayout*: VkImageLayout | |
| 8793 regionCount*: uint32 | |
| 8794 pRegions*: ptr VkBufferImageCopy2 | |
| 8795 VkCopyBufferToImageInfo2KHR* = object | |
| 8796 VkCopyImageToBufferInfo2* = object | |
| 8797 sType*: VkStructureType | |
| 8798 pNext*: pointer | |
| 8799 srcImage*: VkImage | |
| 8800 srcImageLayout*: VkImageLayout | |
| 8801 dstBuffer*: VkBuffer | |
| 8802 regionCount*: uint32 | |
| 8803 pRegions*: ptr VkBufferImageCopy2 | |
| 8804 VkCopyImageToBufferInfo2KHR* = object | |
| 8805 VkResolveImageInfo2* = object | |
| 8806 sType*: VkStructureType | |
| 8807 pNext*: pointer | |
| 8808 srcImage*: VkImage | |
| 8809 srcImageLayout*: VkImageLayout | |
| 8810 dstImage*: VkImage | |
| 8811 dstImageLayout*: VkImageLayout | |
| 8812 regionCount*: uint32 | |
| 8813 pRegions*: ptr VkImageResolve2 | |
| 8814 VkResolveImageInfo2KHR* = object | |
| 8815 VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* = object | |
| 8816 sType*: VkStructureType | |
| 8817 pNext*: pointer | |
| 8818 shaderImageInt64Atomics*: VkBool32 | |
| 8819 sparseImageInt64Atomics*: VkBool32 | |
| 8820 VkFragmentShadingRateAttachmentInfoKHR* = object | |
| 8821 sType*: VkStructureType | |
| 8822 pNext*: pointer | |
| 8823 pFragmentShadingRateAttachment*: ptr VkAttachmentReference2 | |
| 8824 shadingRateAttachmentTexelSize*: VkExtent2D | |
| 8825 VkPipelineFragmentShadingRateStateCreateInfoKHR* = object | |
| 8826 sType*: VkStructureType | |
| 8827 pNext*: pointer | |
| 8828 fragmentSize*: VkExtent2D | |
| 8829 combinerOps*: array[2, VkFragmentShadingRateCombinerOpKHR] | |
| 8830 VkPhysicalDeviceFragmentShadingRateFeaturesKHR* = object | |
| 8831 sType*: VkStructureType | |
| 8832 pNext*: pointer | |
| 8833 pipelineFragmentShadingRate*: VkBool32 | |
| 8834 primitiveFragmentShadingRate*: VkBool32 | |
| 8835 attachmentFragmentShadingRate*: VkBool32 | |
| 8836 VkPhysicalDeviceFragmentShadingRatePropertiesKHR* = object | |
| 8837 sType*: VkStructureType | |
| 8838 pNext*: pointer | |
| 8839 minFragmentShadingRateAttachmentTexelSize*: VkExtent2D | |
| 8840 maxFragmentShadingRateAttachmentTexelSize*: VkExtent2D | |
| 8841 maxFragmentShadingRateAttachmentTexelSizeAspectRatio*: uint32 | |
| 8842 primitiveFragmentShadingRateWithMultipleViewports*: VkBool32 | |
| 8843 layeredShadingRateAttachments*: VkBool32 | |
| 8844 fragmentShadingRateNonTrivialCombinerOps*: VkBool32 | |
| 8845 maxFragmentSize*: VkExtent2D | |
| 8846 maxFragmentSizeAspectRatio*: uint32 | |
| 8847 maxFragmentShadingRateCoverageSamples*: uint32 | |
| 8848 maxFragmentShadingRateRasterizationSamples*: VkSampleCountFlagBits | |
| 8849 fragmentShadingRateWithShaderDepthStencilWrites*: VkBool32 | |
| 8850 fragmentShadingRateWithSampleMask*: VkBool32 | |
| 8851 fragmentShadingRateWithShaderSampleMask*: VkBool32 | |
| 8852 fragmentShadingRateWithConservativeRasterization*: VkBool32 | |
| 8853 fragmentShadingRateWithFragmentShaderInterlock*: VkBool32 | |
| 8854 fragmentShadingRateWithCustomSampleLocations*: VkBool32 | |
| 8855 fragmentShadingRateStrictMultiplyCombiner*: VkBool32 | |
| 8856 VkPhysicalDeviceFragmentShadingRateKHR* = object | |
| 8857 sType*: VkStructureType | |
| 8858 pNext*: pointer | |
| 8859 sampleCounts*: VkSampleCountFlags | |
| 8860 fragmentSize*: VkExtent2D | |
| 8861 VkPhysicalDeviceShaderTerminateInvocationFeatures* = object | |
| 8862 sType*: VkStructureType | |
| 8863 pNext*: pointer | |
| 8864 shaderTerminateInvocation*: VkBool32 | |
| 8865 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* = object | |
| 8866 VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* = object | |
| 8867 sType*: VkStructureType | |
| 8868 pNext*: pointer | |
| 8869 fragmentShadingRateEnums*: VkBool32 | |
| 8870 supersampleFragmentShadingRates*: VkBool32 | |
| 8871 noInvocationFragmentShadingRates*: VkBool32 | |
| 8872 VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* = object | |
| 8873 sType*: VkStructureType | |
| 8874 pNext*: pointer | |
| 8875 maxFragmentShadingRateInvocationCount*: VkSampleCountFlagBits | |
| 8876 VkPipelineFragmentShadingRateEnumStateCreateInfoNV* = object | |
| 8877 sType*: VkStructureType | |
| 8878 pNext*: pointer | |
| 8879 shadingRateType*: VkFragmentShadingRateTypeNV | |
| 8880 shadingRate*: VkFragmentShadingRateNV | |
| 8881 combinerOps*: array[2, VkFragmentShadingRateCombinerOpKHR] | |
| 8882 VkAccelerationStructureBuildSizesInfoKHR* = object | |
| 8883 sType*: VkStructureType | |
| 8884 pNext*: pointer | |
| 8885 accelerationStructureSize*: VkDeviceSize | |
| 8886 updateScratchSize*: VkDeviceSize | |
| 8887 buildScratchSize*: VkDeviceSize | |
| 8888 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* = object | |
| 8889 sType*: VkStructureType | |
| 8890 pNext*: pointer | |
| 8891 image2DViewOf3D*: VkBool32 | |
| 8892 sampler2DViewOf3D*: VkBool32 | |
| 8893 VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* = object | |
| 8894 sType*: VkStructureType | |
| 8895 pNext*: pointer | |
| 8896 imageSlicedViewOf3D*: VkBool32 | |
| 8897 VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* = object | |
| 8898 sType*: VkStructureType | |
| 8899 pNext*: pointer | |
| 8900 mutableDescriptorType*: VkBool32 | |
| 8901 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* = object | |
| 8902 VkMutableDescriptorTypeListEXT* = object | |
| 8903 descriptorTypeCount*: uint32 | |
| 8904 pDescriptorTypes*: ptr VkDescriptorType | |
| 8905 VkMutableDescriptorTypeListVALVE* = object | |
| 8906 VkMutableDescriptorTypeCreateInfoEXT* = object | |
| 8907 sType*: VkStructureType | |
| 8908 pNext*: pointer | |
| 8909 mutableDescriptorTypeListCount*: uint32 | |
| 8910 pMutableDescriptorTypeLists*: ptr VkMutableDescriptorTypeListEXT | |
| 8911 VkMutableDescriptorTypeCreateInfoVALVE* = object | |
| 8912 VkPhysicalDeviceDepthClipControlFeaturesEXT* = object | |
| 8913 sType*: VkStructureType | |
| 8914 pNext*: pointer | |
| 8915 depthClipControl*: VkBool32 | |
| 8916 VkPipelineViewportDepthClipControlCreateInfoEXT* = object | |
| 8917 sType*: VkStructureType | |
| 8918 pNext*: pointer | |
| 8919 negativeOneToOne*: VkBool32 | |
| 8920 VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* = object | |
| 8921 sType*: VkStructureType | |
| 8922 pNext*: pointer | |
| 8923 vertexInputDynamicState*: VkBool32 | |
| 8924 VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* = object | |
| 8925 sType*: VkStructureType | |
| 8926 pNext*: pointer | |
| 8927 externalMemoryRDMA*: VkBool32 | |
| 8928 VkVertexInputBindingDescription2EXT* = object | |
| 8929 sType*: VkStructureType | |
| 8930 pNext*: pointer | |
| 8931 binding*: uint32 | |
| 8932 stride*: uint32 | |
| 8933 inputRate*: VkVertexInputRate | |
| 8934 divisor*: uint32 | |
| 8935 VkVertexInputAttributeDescription2EXT* = object | |
| 8936 sType*: VkStructureType | |
| 8937 pNext*: pointer | |
| 8938 location*: uint32 | |
| 8939 binding*: uint32 | |
| 8940 format*: VkFormat | |
| 8941 offset*: uint32 | |
| 8942 VkPhysicalDeviceColorWriteEnableFeaturesEXT* = object | |
| 8943 sType*: VkStructureType | |
| 8944 pNext*: pointer | |
| 8945 colorWriteEnable*: VkBool32 | |
| 8946 VkPipelineColorWriteCreateInfoEXT* = object | |
| 8947 sType*: VkStructureType | |
| 8948 pNext*: pointer | |
| 8949 attachmentCount*: uint32 | |
| 8950 pColorWriteEnables*: ptr VkBool32 | |
| 8951 VkMemoryBarrier2* = object | |
| 8952 sType*: VkStructureType | |
| 8953 pNext*: pointer | |
| 8954 srcStageMask*: VkPipelineStageFlags2 | |
| 8955 srcAccessMask*: VkAccessFlags2 | |
| 8956 dstStageMask*: VkPipelineStageFlags2 | |
| 8957 dstAccessMask*: VkAccessFlags2 | |
| 8958 VkMemoryBarrier2KHR* = object | |
| 8959 VkImageMemoryBarrier2* = object | |
| 8960 sType*: VkStructureType | |
| 8961 pNext*: pointer | |
| 8962 srcStageMask*: VkPipelineStageFlags2 | |
| 8963 srcAccessMask*: VkAccessFlags2 | |
| 8964 dstStageMask*: VkPipelineStageFlags2 | |
| 8965 dstAccessMask*: VkAccessFlags2 | |
| 8966 oldLayout*: VkImageLayout | |
| 8967 newLayout*: VkImageLayout | |
| 8968 srcQueueFamilyIndex*: uint32 | |
| 8969 dstQueueFamilyIndex*: uint32 | |
| 8970 image*: VkImage | |
| 8971 subresourceRange*: VkImageSubresourceRange | |
| 8972 VkImageMemoryBarrier2KHR* = object | |
| 8973 VkBufferMemoryBarrier2* = object | |
| 8974 sType*: VkStructureType | |
| 8975 pNext*: pointer | |
| 8976 srcStageMask*: VkPipelineStageFlags2 | |
| 8977 srcAccessMask*: VkAccessFlags2 | |
| 8978 dstStageMask*: VkPipelineStageFlags2 | |
| 8979 dstAccessMask*: VkAccessFlags2 | |
| 8980 srcQueueFamilyIndex*: uint32 | |
| 8981 dstQueueFamilyIndex*: uint32 | |
| 8982 buffer*: VkBuffer | |
| 8983 offset*: VkDeviceSize | |
| 8984 size*: VkDeviceSize | |
| 8985 VkBufferMemoryBarrier2KHR* = object | |
| 8986 VkDependencyInfo* = object | |
| 8987 sType*: VkStructureType | |
| 8988 pNext*: pointer | |
| 8989 dependencyFlags*: VkDependencyFlags | |
| 8990 memoryBarrierCount*: uint32 | |
| 8991 pMemoryBarriers*: ptr VkMemoryBarrier2 | |
| 8992 bufferMemoryBarrierCount*: uint32 | |
| 8993 pBufferMemoryBarriers*: ptr VkBufferMemoryBarrier2 | |
| 8994 imageMemoryBarrierCount*: uint32 | |
| 8995 pImageMemoryBarriers*: ptr VkImageMemoryBarrier2 | |
| 8996 VkDependencyInfoKHR* = object | |
| 8997 VkSemaphoreSubmitInfo* = object | |
| 8998 sType*: VkStructureType | |
| 8999 pNext*: pointer | |
| 9000 semaphore*: VkSemaphore | |
| 9001 value*: uint64 | |
| 9002 stageMask*: VkPipelineStageFlags2 | |
| 9003 deviceIndex*: uint32 | |
| 9004 VkSemaphoreSubmitInfoKHR* = object | |
| 9005 VkCommandBufferSubmitInfo* = object | |
| 9006 sType*: VkStructureType | |
| 9007 pNext*: pointer | |
| 9008 commandBuffer*: VkCommandBuffer | |
| 9009 deviceMask*: uint32 | |
| 9010 VkCommandBufferSubmitInfoKHR* = object | |
| 9011 VkSubmitInfo2* = object | |
| 9012 sType*: VkStructureType | |
| 9013 pNext*: pointer | |
| 9014 flags*: VkSubmitFlags | |
| 9015 waitSemaphoreInfoCount*: uint32 | |
| 9016 pWaitSemaphoreInfos*: ptr VkSemaphoreSubmitInfo | |
| 9017 commandBufferInfoCount*: uint32 | |
| 9018 pCommandBufferInfos*: ptr VkCommandBufferSubmitInfo | |
| 9019 signalSemaphoreInfoCount*: uint32 | |
| 9020 pSignalSemaphoreInfos*: ptr VkSemaphoreSubmitInfo | |
| 9021 VkSubmitInfo2KHR* = object | |
| 9022 VkQueueFamilyCheckpointProperties2NV* = object | |
| 9023 sType*: VkStructureType | |
| 9024 pNext*: pointer | |
| 9025 checkpointExecutionStageMask*: VkPipelineStageFlags2 | |
| 9026 VkCheckpointData2NV* = object | |
| 9027 sType*: VkStructureType | |
| 9028 pNext*: pointer | |
| 9029 stage*: VkPipelineStageFlags2 | |
| 9030 pCheckpointMarker*: pointer | |
| 9031 VkPhysicalDeviceSynchronization2Features* = object | |
| 9032 sType*: VkStructureType | |
| 9033 pNext*: pointer | |
| 9034 synchronization2*: VkBool32 | |
| 9035 VkPhysicalDeviceSynchronization2FeaturesKHR* = object | |
| 9036 VkPhysicalDeviceVulkanSC10Properties* = object | |
| 9037 sType*: VkStructureType | |
| 9038 pNext*: pointer | |
| 9039 deviceNoDynamicHostAllocations*: VkBool32 | |
| 9040 deviceDestroyFreesMemory*: VkBool32 | |
| 9041 commandPoolMultipleCommandBuffersRecording*: VkBool32 | |
| 9042 commandPoolResetCommandBuffer*: VkBool32 | |
| 9043 commandBufferSimultaneousUse*: VkBool32 | |
| 9044 secondaryCommandBufferNullOrImagelessFramebuffer*: VkBool32 | |
| 9045 recycleDescriptorSetMemory*: VkBool32 | |
| 9046 recyclePipelineMemory*: VkBool32 | |
| 9047 maxRenderPassSubpasses*: uint32 | |
| 9048 maxRenderPassDependencies*: uint32 | |
| 9049 maxSubpassInputAttachments*: uint32 | |
| 9050 maxSubpassPreserveAttachments*: uint32 | |
| 9051 maxFramebufferAttachments*: uint32 | |
| 9052 maxDescriptorSetLayoutBindings*: uint32 | |
| 9053 maxQueryFaultCount*: uint32 | |
| 9054 maxCallbackFaultCount*: uint32 | |
| 9055 maxCommandPoolCommandBuffers*: uint32 | |
| 9056 maxCommandBufferSize*: VkDeviceSize | |
| 9057 VkPipelinePoolSize* = object | |
| 9058 sType*: VkStructureType | |
| 9059 pNext*: pointer | |
| 9060 poolEntrySize*: VkDeviceSize | |
| 9061 poolEntryCount*: uint32 | |
| 9062 VkDeviceObjectReservationCreateInfo* = object | |
| 9063 sType*: VkStructureType | |
| 9064 pNext*: pointer | |
| 9065 pipelineCacheCreateInfoCount*: uint32 | |
| 9066 pPipelineCacheCreateInfos*: ptr VkPipelineCacheCreateInfo | |
| 9067 pipelinePoolSizeCount*: uint32 | |
| 9068 pPipelinePoolSizes*: ptr VkPipelinePoolSize | |
| 9069 semaphoreRequestCount*: uint32 | |
| 9070 commandBufferRequestCount*: uint32 | |
| 9071 fenceRequestCount*: uint32 | |
| 9072 deviceMemoryRequestCount*: uint32 | |
| 9073 bufferRequestCount*: uint32 | |
| 9074 imageRequestCount*: uint32 | |
| 9075 eventRequestCount*: uint32 | |
| 9076 queryPoolRequestCount*: uint32 | |
| 9077 bufferViewRequestCount*: uint32 | |
| 9078 imageViewRequestCount*: uint32 | |
| 9079 layeredImageViewRequestCount*: uint32 | |
| 9080 pipelineCacheRequestCount*: uint32 | |
| 9081 pipelineLayoutRequestCount*: uint32 | |
| 9082 renderPassRequestCount*: uint32 | |
| 9083 graphicsPipelineRequestCount*: uint32 | |
| 9084 computePipelineRequestCount*: uint32 | |
| 9085 descriptorSetLayoutRequestCount*: uint32 | |
| 9086 samplerRequestCount*: uint32 | |
| 9087 descriptorPoolRequestCount*: uint32 | |
| 9088 descriptorSetRequestCount*: uint32 | |
| 9089 framebufferRequestCount*: uint32 | |
| 9090 commandPoolRequestCount*: uint32 | |
| 9091 samplerYcbcrConversionRequestCount*: uint32 | |
| 9092 surfaceRequestCount*: uint32 | |
| 9093 swapchainRequestCount*: uint32 | |
| 9094 displayModeRequestCount*: uint32 | |
| 9095 subpassDescriptionRequestCount*: uint32 | |
| 9096 attachmentDescriptionRequestCount*: uint32 | |
| 9097 descriptorSetLayoutBindingRequestCount*: uint32 | |
| 9098 descriptorSetLayoutBindingLimit*: uint32 | |
| 9099 maxImageViewMipLevels*: uint32 | |
| 9100 maxImageViewArrayLayers*: uint32 | |
| 9101 maxLayeredImageViewMipLevels*: uint32 | |
| 9102 maxOcclusionQueriesPerPool*: uint32 | |
| 9103 maxPipelineStatisticsQueriesPerPool*: uint32 | |
| 9104 maxTimestampQueriesPerPool*: uint32 | |
| 9105 maxImmutableSamplersPerDescriptorSetLayout*: uint32 | |
| 9106 VkCommandPoolMemoryReservationCreateInfo* = object | |
| 9107 sType*: VkStructureType | |
| 9108 pNext*: pointer | |
| 9109 commandPoolReservedSize*: VkDeviceSize | |
| 9110 commandPoolMaxCommandBuffers*: uint32 | |
| 9111 VkCommandPoolMemoryConsumption* = object | |
| 9112 sType*: VkStructureType | |
| 9113 pNext*: pointer | |
| 9114 commandPoolAllocated*: VkDeviceSize | |
| 9115 commandPoolReservedSize*: VkDeviceSize | |
| 9116 commandBufferAllocated*: VkDeviceSize | |
| 9117 VkPhysicalDeviceVulkanSC10Features* = object | |
| 9118 sType*: VkStructureType | |
| 9119 pNext*: pointer | |
| 9120 shaderAtomicInstructions*: VkBool32 | |
| 9121 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* = object | |
| 9122 sType*: VkStructureType | |
| 9123 pNext*: pointer | |
| 9124 primitivesGeneratedQuery*: VkBool32 | |
| 9125 primitivesGeneratedQueryWithRasterizerDiscard*: VkBool32 | |
| 9126 primitivesGeneratedQueryWithNonZeroStreams*: VkBool32 | |
| 9127 VkPhysicalDeviceLegacyDitheringFeaturesEXT* = object | |
| 9128 sType*: VkStructureType | |
| 9129 pNext*: pointer | |
| 9130 legacyDithering*: VkBool32 | |
| 9131 VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* = object | |
| 9132 sType*: VkStructureType | |
| 9133 pNext*: pointer | |
| 9134 multisampledRenderToSingleSampled*: VkBool32 | |
| 9135 VkSubpassResolvePerformanceQueryEXT* = object | |
| 9136 sType*: VkStructureType | |
| 9137 pNext*: pointer | |
| 9138 optimal*: VkBool32 | |
| 9139 VkMultisampledRenderToSingleSampledInfoEXT* = object | |
| 9140 sType*: VkStructureType | |
| 9141 pNext*: pointer | |
| 9142 multisampledRenderToSingleSampledEnable*: VkBool32 | |
| 9143 rasterizationSamples*: VkSampleCountFlagBits | |
| 9144 VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* = object | |
| 9145 sType*: VkStructureType | |
| 9146 pNext*: pointer | |
| 9147 pipelineProtectedAccess*: VkBool32 | |
| 9148 VkPhysicalDeviceInheritedViewportScissorFeaturesNV* = object | |
| 9149 sType*: VkStructureType | |
| 9150 pNext*: pointer | |
| 9151 inheritedViewportScissor2D*: VkBool32 | |
| 9152 VkCommandBufferInheritanceViewportScissorInfoNV* = object | |
| 9153 sType*: VkStructureType | |
| 9154 pNext*: pointer | |
| 9155 viewportScissor2D*: VkBool32 | |
| 9156 viewportDepthCount*: uint32 | |
| 9157 pViewportDepths*: ptr VkViewport | |
| 9158 VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* = object | |
| 9159 sType*: VkStructureType | |
| 9160 pNext*: pointer | |
| 9161 ycbcr2plane444Formats*: VkBool32 | |
| 9162 VkPhysicalDeviceProvokingVertexFeaturesEXT* = object | |
| 9163 sType*: VkStructureType | |
| 9164 pNext*: pointer | |
| 9165 provokingVertexLast*: VkBool32 | |
| 9166 transformFeedbackPreservesProvokingVertex*: VkBool32 | |
| 9167 VkPhysicalDeviceProvokingVertexPropertiesEXT* = object | |
| 9168 sType*: VkStructureType | |
| 9169 pNext*: pointer | |
| 9170 provokingVertexModePerPipeline*: VkBool32 | |
| 9171 transformFeedbackPreservesTriangleFanProvokingVertex*: VkBool32 | |
| 9172 VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* = object | |
| 9173 sType*: VkStructureType | |
| 9174 pNext*: pointer | |
| 9175 provokingVertexMode*: VkProvokingVertexModeEXT | |
| 9176 VkCuModuleCreateInfoNVX* = object | |
| 9177 sType*: VkStructureType | |
| 9178 pNext*: pointer | |
| 9179 dataSize*: csize_t | |
| 9180 pData*: pointer | |
| 9181 VkCuFunctionCreateInfoNVX* = object | |
| 9182 sType*: VkStructureType | |
| 9183 pNext*: pointer | |
| 9184 module*: VkCuModuleNVX | |
| 9185 pName*: cstring | |
| 9186 VkCuLaunchInfoNVX* = object | |
| 9187 sType*: VkStructureType | |
| 9188 pNext*: pointer | |
| 9189 function*: VkCuFunctionNVX | |
| 9190 gridDimX*: uint32 | |
| 9191 gridDimY*: uint32 | |
| 9192 gridDimZ*: uint32 | |
| 9193 blockDimX*: uint32 | |
| 9194 blockDimY*: uint32 | |
| 9195 blockDimZ*: uint32 | |
| 9196 sharedMemBytes*: uint32 | |
| 9197 paramCount*: csize_t | |
| 9198 pParams*: ptr pointer | |
| 9199 extraCount*: csize_t | |
| 9200 pExtras*: ptr pointer | |
| 9201 VkPhysicalDeviceDescriptorBufferFeaturesEXT* = object | |
| 9202 sType*: VkStructureType | |
| 9203 pNext*: pointer | |
| 9204 descriptorBuffer*: VkBool32 | |
| 9205 descriptorBufferCaptureReplay*: VkBool32 | |
| 9206 descriptorBufferImageLayoutIgnored*: VkBool32 | |
| 9207 descriptorBufferPushDescriptors*: VkBool32 | |
| 9208 VkPhysicalDeviceDescriptorBufferPropertiesEXT* = object | |
| 9209 sType*: VkStructureType | |
| 9210 pNext*: pointer | |
| 9211 combinedImageSamplerDescriptorSingleArray*: VkBool32 | |
| 9212 bufferlessPushDescriptors*: VkBool32 | |
| 9213 allowSamplerImageViewPostSubmitCreation*: VkBool32 | |
| 9214 descriptorBufferOffsetAlignment*: VkDeviceSize | |
| 9215 maxDescriptorBufferBindings*: uint32 | |
| 9216 maxResourceDescriptorBufferBindings*: uint32 | |
| 9217 maxSamplerDescriptorBufferBindings*: uint32 | |
| 9218 maxEmbeddedImmutableSamplerBindings*: uint32 | |
| 9219 maxEmbeddedImmutableSamplers*: uint32 | |
| 9220 bufferCaptureReplayDescriptorDataSize*: csize_t | |
| 9221 imageCaptureReplayDescriptorDataSize*: csize_t | |
| 9222 imageViewCaptureReplayDescriptorDataSize*: csize_t | |
| 9223 samplerCaptureReplayDescriptorDataSize*: csize_t | |
| 9224 accelerationStructureCaptureReplayDescriptorDataSize*: csize_t | |
| 9225 samplerDescriptorSize*: csize_t | |
| 9226 combinedImageSamplerDescriptorSize*: csize_t | |
| 9227 sampledImageDescriptorSize*: csize_t | |
| 9228 storageImageDescriptorSize*: csize_t | |
| 9229 uniformTexelBufferDescriptorSize*: csize_t | |
| 9230 robustUniformTexelBufferDescriptorSize*: csize_t | |
| 9231 storageTexelBufferDescriptorSize*: csize_t | |
| 9232 robustStorageTexelBufferDescriptorSize*: csize_t | |
| 9233 uniformBufferDescriptorSize*: csize_t | |
| 9234 robustUniformBufferDescriptorSize*: csize_t | |
| 9235 storageBufferDescriptorSize*: csize_t | |
| 9236 robustStorageBufferDescriptorSize*: csize_t | |
| 9237 inputAttachmentDescriptorSize*: csize_t | |
| 9238 accelerationStructureDescriptorSize*: csize_t | |
| 9239 maxSamplerDescriptorBufferRange*: VkDeviceSize | |
| 9240 maxResourceDescriptorBufferRange*: VkDeviceSize | |
| 9241 samplerDescriptorBufferAddressSpaceSize*: VkDeviceSize | |
| 9242 resourceDescriptorBufferAddressSpaceSize*: VkDeviceSize | |
| 9243 descriptorBufferAddressSpaceSize*: VkDeviceSize | |
| 9244 VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* = object | |
| 9245 sType*: VkStructureType | |
| 9246 pNext*: pointer | |
| 9247 combinedImageSamplerDensityMapDescriptorSize*: csize_t | |
| 9248 VkDescriptorAddressInfoEXT* = object | |
| 9249 sType*: VkStructureType | |
| 9250 pNext*: pointer | |
| 9251 address*: VkDeviceAddress | |
| 9252 range*: VkDeviceSize | |
| 9253 format*: VkFormat | |
| 9254 VkDescriptorBufferBindingInfoEXT* = object | |
| 9255 sType*: VkStructureType | |
| 9256 pNext*: pointer | |
| 9257 address*: VkDeviceAddress | |
| 9258 usage*: VkBufferUsageFlags | |
| 9259 VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* = object | |
| 9260 sType*: VkStructureType | |
| 9261 pNext*: pointer | |
| 9262 buffer*: VkBuffer | |
| 9263 VkDescriptorDataEXT* {.union.} = object | |
| 9264 pSampler*: ptr VkSampler | |
| 9265 pCombinedImageSampler*: ptr VkDescriptorImageInfo | |
| 9266 pInputAttachmentImage*: ptr VkDescriptorImageInfo | |
| 9267 pSampledImage*: ptr VkDescriptorImageInfo | |
| 9268 pStorageImage*: ptr VkDescriptorImageInfo | |
| 9269 pUniformTexelBuffer*: ptr VkDescriptorAddressInfoEXT | |
| 9270 pStorageTexelBuffer*: ptr VkDescriptorAddressInfoEXT | |
| 9271 pUniformBuffer*: ptr VkDescriptorAddressInfoEXT | |
| 9272 pStorageBuffer*: ptr VkDescriptorAddressInfoEXT | |
| 9273 accelerationStructure*: VkDeviceAddress | |
| 9274 VkDescriptorGetInfoEXT* = object | |
| 9275 sType*: VkStructureType | |
| 9276 pNext*: pointer | |
| 9277 thetype*: VkDescriptorType | |
| 9278 data*: VkDescriptorDataEXT | |
| 9279 VkBufferCaptureDescriptorDataInfoEXT* = object | |
| 9280 sType*: VkStructureType | |
| 9281 pNext*: pointer | |
| 9282 buffer*: VkBuffer | |
| 9283 VkImageCaptureDescriptorDataInfoEXT* = object | |
| 9284 sType*: VkStructureType | |
| 9285 pNext*: pointer | |
| 9286 image*: VkImage | |
| 9287 VkImageViewCaptureDescriptorDataInfoEXT* = object | |
| 9288 sType*: VkStructureType | |
| 9289 pNext*: pointer | |
| 9290 imageView*: VkImageView | |
| 9291 VkSamplerCaptureDescriptorDataInfoEXT* = object | |
| 9292 sType*: VkStructureType | |
| 9293 pNext*: pointer | |
| 9294 sampler*: VkSampler | |
| 9295 VkAccelerationStructureCaptureDescriptorDataInfoEXT* = object | |
| 9296 sType*: VkStructureType | |
| 9297 pNext*: pointer | |
| 9298 accelerationStructure*: VkAccelerationStructureKHR | |
| 9299 accelerationStructureNV*: VkAccelerationStructureNV | |
| 9300 VkOpaqueCaptureDescriptorDataCreateInfoEXT* = object | |
| 9301 sType*: VkStructureType | |
| 9302 pNext*: pointer | |
| 9303 opaqueCaptureDescriptorData*: pointer | |
| 9304 VkPhysicalDeviceShaderIntegerDotProductFeatures* = object | |
| 9305 sType*: VkStructureType | |
| 9306 pNext*: pointer | |
| 9307 shaderIntegerDotProduct*: VkBool32 | |
| 9308 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* = object | |
| 9309 VkPhysicalDeviceShaderIntegerDotProductProperties* = object | |
| 9310 sType*: VkStructureType | |
| 9311 pNext*: pointer | |
| 9312 integerDotProduct8BitUnsignedAccelerated*: VkBool32 | |
| 9313 integerDotProduct8BitSignedAccelerated*: VkBool32 | |
| 9314 integerDotProduct8BitMixedSignednessAccelerated*: VkBool32 | |
| 9315 integerDotProduct4x8BitPackedUnsignedAccelerated*: VkBool32 | |
| 9316 integerDotProduct4x8BitPackedSignedAccelerated*: VkBool32 | |
| 9317 integerDotProduct4x8BitPackedMixedSignednessAccelerated*: VkBool32 | |
| 9318 integerDotProduct16BitUnsignedAccelerated*: VkBool32 | |
| 9319 integerDotProduct16BitSignedAccelerated*: VkBool32 | |
| 9320 integerDotProduct16BitMixedSignednessAccelerated*: VkBool32 | |
| 9321 integerDotProduct32BitUnsignedAccelerated*: VkBool32 | |
| 9322 integerDotProduct32BitSignedAccelerated*: VkBool32 | |
| 9323 integerDotProduct32BitMixedSignednessAccelerated*: VkBool32 | |
| 9324 integerDotProduct64BitUnsignedAccelerated*: VkBool32 | |
| 9325 integerDotProduct64BitSignedAccelerated*: VkBool32 | |
| 9326 integerDotProduct64BitMixedSignednessAccelerated*: VkBool32 | |
| 9327 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated*: VkBool32 | |
| 9328 integerDotProductAccumulatingSaturating8BitSignedAccelerated*: VkBool32 | |
| 9329 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated*: VkBool32 | |
| 9330 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated*: VkBool32 | |
| 9331 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated*: VkBool32 | |
| 9332 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated*: VkBool32 | |
| 9333 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated*: VkBool32 | |
| 9334 integerDotProductAccumulatingSaturating16BitSignedAccelerated*: VkBool32 | |
| 9335 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated*: VkBool32 | |
| 9336 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated*: VkBool32 | |
| 9337 integerDotProductAccumulatingSaturating32BitSignedAccelerated*: VkBool32 | |
| 9338 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated*: VkBool32 | |
| 9339 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated*: VkBool32 | |
| 9340 integerDotProductAccumulatingSaturating64BitSignedAccelerated*: VkBool32 | |
| 9341 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated*: VkBool32 | |
| 9342 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* = object | |
| 9343 VkPhysicalDeviceDrmPropertiesEXT* = object | |
| 9344 sType*: VkStructureType | |
| 9345 pNext*: pointer | |
| 9346 hasPrimary*: VkBool32 | |
| 9347 hasRender*: VkBool32 | |
| 9348 primaryMajor*: int64 | |
| 9349 primaryMinor*: int64 | |
| 9350 renderMajor*: int64 | |
| 9351 renderMinor*: int64 | |
| 9352 VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* = object | |
| 9353 sType*: VkStructureType | |
| 9354 pNext*: pointer | |
| 9355 fragmentShaderBarycentric*: VkBool32 | |
| 9356 VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* = object | |
| 9357 sType*: VkStructureType | |
| 9358 pNext*: pointer | |
| 9359 triStripVertexOrderIndependentOfProvokingVertex*: VkBool32 | |
| 9360 VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* = object | |
| 9361 sType*: VkStructureType | |
| 9362 pNext*: pointer | |
| 9363 rayTracingMotionBlur*: VkBool32 | |
| 9364 rayTracingMotionBlurPipelineTraceRaysIndirect*: VkBool32 | |
| 9365 VkAccelerationStructureGeometryMotionTrianglesDataNV* = object | |
| 9366 sType*: VkStructureType | |
| 9367 pNext*: pointer | |
| 9368 vertexData*: VkDeviceOrHostAddressConstKHR | |
| 9369 VkAccelerationStructureMotionInfoNV* = object | |
| 9370 sType*: VkStructureType | |
| 9371 pNext*: pointer | |
| 9372 maxInstances*: uint32 | |
| 9373 flags*: VkAccelerationStructureMotionInfoFlagsNV | |
| 9374 VkSRTDataNV* = object | |
| 9375 sx*: float32 | |
| 9376 a*: float32 | |
| 9377 b*: float32 | |
| 9378 pvx*: float32 | |
| 9379 sy*: float32 | |
| 9380 c*: float32 | |
| 9381 pvy*: float32 | |
| 9382 sz*: float32 | |
| 9383 pvz*: float32 | |
| 9384 qx*: float32 | |
| 9385 qy*: float32 | |
| 9386 qz*: float32 | |
| 9387 qw*: float32 | |
| 9388 tx*: float32 | |
| 9389 ty*: float32 | |
| 9390 tz*: float32 | |
| 9391 VkAccelerationStructureSRTMotionInstanceNV* = object | |
| 9392 transformT0*: VkSRTDataNV | |
| 9393 transformT1*: VkSRTDataNV | |
| 9394 instanceCustomIndex*: uint32 | |
| 9395 mask*: uint32 | |
| 9396 instanceShaderBindingTableRecordOffset*: uint32 | |
| 9397 flags*: VkGeometryInstanceFlagsKHR | |
| 9398 accelerationStructureReference*: uint64 | |
| 9399 VkAccelerationStructureMatrixMotionInstanceNV* = object | |
| 9400 transformT0*: VkTransformMatrixKHR | |
| 9401 transformT1*: VkTransformMatrixKHR | |
| 9402 instanceCustomIndex*: uint32 | |
| 9403 mask*: uint32 | |
| 9404 instanceShaderBindingTableRecordOffset*: uint32 | |
| 9405 flags*: VkGeometryInstanceFlagsKHR | |
| 9406 accelerationStructureReference*: uint64 | |
| 9407 VkAccelerationStructureMotionInstanceDataNV* {.union.} = object | |
| 9408 staticInstance*: VkAccelerationStructureInstanceKHR | |
| 9409 matrixMotionInstance*: VkAccelerationStructureMatrixMotionInstanceNV | |
| 9410 srtMotionInstance*: VkAccelerationStructureSRTMotionInstanceNV | |
| 9411 VkAccelerationStructureMotionInstanceNV* = object | |
| 9412 thetype*: VkAccelerationStructureMotionInstanceTypeNV | |
| 9413 flags*: VkAccelerationStructureMotionInstanceFlagsNV | |
| 9414 data*: VkAccelerationStructureMotionInstanceDataNV | |
| 9415 VkMemoryGetRemoteAddressInfoNV* = object | |
| 9416 sType*: VkStructureType | |
| 9417 pNext*: pointer | |
| 9418 memory*: VkDeviceMemory | |
| 9419 handleType*: VkExternalMemoryHandleTypeFlagBits | |
| 9420 VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* = object | |
| 9421 sType*: VkStructureType | |
| 9422 pNext*: pointer | |
| 9423 formatRgba10x6WithoutYCbCrSampler*: VkBool32 | |
| 9424 VkFormatProperties3* = object | |
| 9425 sType*: VkStructureType | |
| 9426 pNext*: pointer | |
| 9427 linearTilingFeatures*: VkFormatFeatureFlags2 | |
| 9428 optimalTilingFeatures*: VkFormatFeatureFlags2 | |
| 9429 bufferFeatures*: VkFormatFeatureFlags2 | |
| 9430 VkFormatProperties3KHR* = object | |
| 9431 VkDrmFormatModifierPropertiesList2EXT* = object | |
| 9432 sType*: VkStructureType | |
| 9433 pNext*: pointer | |
| 9434 drmFormatModifierCount*: uint32 | |
| 9435 pDrmFormatModifierProperties*: ptr VkDrmFormatModifierProperties2EXT | |
| 9436 VkDrmFormatModifierProperties2EXT* = object | |
| 9437 drmFormatModifier*: uint64 | |
| 9438 drmFormatModifierPlaneCount*: uint32 | |
| 9439 drmFormatModifierTilingFeatures*: VkFormatFeatureFlags2 | |
| 9440 VkPipelineRenderingCreateInfo* = object | |
| 9441 sType*: VkStructureType | |
| 9442 pNext*: pointer | |
| 9443 viewMask*: uint32 | |
| 9444 colorAttachmentCount*: uint32 | |
| 9445 pColorAttachmentFormats*: ptr VkFormat | |
| 9446 depthAttachmentFormat*: VkFormat | |
| 9447 stencilAttachmentFormat*: VkFormat | |
| 9448 VkPipelineRenderingCreateInfoKHR* = object | |
| 9449 VkRenderingInfo* = object | |
| 9450 sType*: VkStructureType | |
| 9451 pNext*: pointer | |
| 9452 flags*: VkRenderingFlags | |
| 9453 renderArea*: VkRect2D | |
| 9454 layerCount*: uint32 | |
| 9455 viewMask*: uint32 | |
| 9456 colorAttachmentCount*: uint32 | |
| 9457 pColorAttachments*: ptr VkRenderingAttachmentInfo | |
| 9458 pDepthAttachment*: ptr VkRenderingAttachmentInfo | |
| 9459 pStencilAttachment*: ptr VkRenderingAttachmentInfo | |
| 9460 VkRenderingInfoKHR* = object | |
| 9461 VkRenderingAttachmentInfo* = object | |
| 9462 sType*: VkStructureType | |
| 9463 pNext*: pointer | |
| 9464 imageView*: VkImageView | |
| 9465 imageLayout*: VkImageLayout | |
| 9466 resolveMode*: VkResolveModeFlagBits | |
| 9467 resolveImageView*: VkImageView | |
| 9468 resolveImageLayout*: VkImageLayout | |
| 9469 loadOp*: VkAttachmentLoadOp | |
| 9470 storeOp*: VkAttachmentStoreOp | |
| 9471 clearValue*: VkClearValue | |
| 9472 VkRenderingAttachmentInfoKHR* = object | |
| 9473 VkRenderingFragmentShadingRateAttachmentInfoKHR* = object | |
| 9474 sType*: VkStructureType | |
| 9475 pNext*: pointer | |
| 9476 imageView*: VkImageView | |
| 9477 imageLayout*: VkImageLayout | |
| 9478 shadingRateAttachmentTexelSize*: VkExtent2D | |
| 9479 VkRenderingFragmentDensityMapAttachmentInfoEXT* = object | |
| 9480 sType*: VkStructureType | |
| 9481 pNext*: pointer | |
| 9482 imageView*: VkImageView | |
| 9483 imageLayout*: VkImageLayout | |
| 9484 VkPhysicalDeviceDynamicRenderingFeatures* = object | |
| 9485 sType*: VkStructureType | |
| 9486 pNext*: pointer | |
| 9487 dynamicRendering*: VkBool32 | |
| 9488 VkPhysicalDeviceDynamicRenderingFeaturesKHR* = object | |
| 9489 VkCommandBufferInheritanceRenderingInfo* = object | |
| 9490 sType*: VkStructureType | |
| 9491 pNext*: pointer | |
| 9492 flags*: VkRenderingFlags | |
| 9493 viewMask*: uint32 | |
| 9494 colorAttachmentCount*: uint32 | |
| 9495 pColorAttachmentFormats*: ptr VkFormat | |
| 9496 depthAttachmentFormat*: VkFormat | |
| 9497 stencilAttachmentFormat*: VkFormat | |
| 9498 rasterizationSamples*: VkSampleCountFlagBits | |
| 9499 VkCommandBufferInheritanceRenderingInfoKHR* = object | |
| 9500 VkAttachmentSampleCountInfoAMD* = object | |
| 9501 sType*: VkStructureType | |
| 9502 pNext*: pointer | |
| 9503 colorAttachmentCount*: uint32 | |
| 9504 pColorAttachmentSamples*: ptr VkSampleCountFlagBits | |
| 9505 depthStencilAttachmentSamples*: VkSampleCountFlagBits | |
| 9506 VkAttachmentSampleCountInfoNV* = object | |
| 9507 VkMultiviewPerViewAttributesInfoNVX* = object | |
| 9508 sType*: VkStructureType | |
| 9509 pNext*: pointer | |
| 9510 perViewAttributes*: VkBool32 | |
| 9511 perViewAttributesPositionXOnly*: VkBool32 | |
| 9512 VkPhysicalDeviceImageViewMinLodFeaturesEXT* = object | |
| 9513 sType*: VkStructureType | |
| 9514 pNext*: pointer | |
| 9515 minLod*: VkBool32 | |
| 9516 VkImageViewMinLodCreateInfoEXT* = object | |
| 9517 sType*: VkStructureType | |
| 9518 pNext*: pointer | |
| 9519 minLod*: float32 | |
| 9520 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* = object | |
| 9521 sType*: VkStructureType | |
| 9522 pNext*: pointer | |
| 9523 rasterizationOrderColorAttachmentAccess*: VkBool32 | |
| 9524 rasterizationOrderDepthAttachmentAccess*: VkBool32 | |
| 9525 rasterizationOrderStencilAttachmentAccess*: VkBool32 | |
| 9526 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM* = object | |
| 9527 VkPhysicalDeviceLinearColorAttachmentFeaturesNV* = object | |
| 9528 sType*: VkStructureType | |
| 9529 pNext*: pointer | |
| 9530 linearColorAttachment*: VkBool32 | |
| 9531 VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* = object | |
| 9532 sType*: VkStructureType | |
| 9533 pNext*: pointer | |
| 9534 graphicsPipelineLibrary*: VkBool32 | |
| 9535 VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* = object | |
| 9536 sType*: VkStructureType | |
| 9537 pNext*: pointer | |
| 9538 graphicsPipelineLibraryFastLinking*: VkBool32 | |
| 9539 graphicsPipelineLibraryIndependentInterpolationDecoration*: VkBool32 | |
| 9540 VkGraphicsPipelineLibraryCreateInfoEXT* = object | |
| 9541 sType*: VkStructureType | |
| 9542 pNext*: pointer | |
| 9543 flags*: VkGraphicsPipelineLibraryFlagsEXT | |
| 9544 VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* = object | |
| 9545 sType*: VkStructureType | |
| 9546 pNext*: pointer | |
| 9547 descriptorSetHostMapping*: VkBool32 | |
| 9548 VkDescriptorSetBindingReferenceVALVE* = object | |
| 9549 sType*: VkStructureType | |
| 9550 pNext*: pointer | |
| 9551 descriptorSetLayout*: VkDescriptorSetLayout | |
| 9552 binding*: uint32 | |
| 9553 VkDescriptorSetLayoutHostMappingInfoVALVE* = object | |
| 9554 sType*: VkStructureType | |
| 9555 pNext*: pointer | |
| 9556 descriptorOffset*: csize_t | |
| 9557 descriptorSize*: uint32 | |
| 9558 VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* = object | |
| 9559 sType*: VkStructureType | |
| 9560 pNext*: pointer | |
| 9561 shaderModuleIdentifier*: VkBool32 | |
| 9562 VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* = object | |
| 9563 sType*: VkStructureType | |
| 9564 pNext*: pointer | |
| 9565 shaderModuleIdentifierAlgorithmUUID*: array[VK_UUID_SIZE, uint8] | |
| 9566 VkPipelineShaderStageModuleIdentifierCreateInfoEXT* = object | |
| 9567 sType*: VkStructureType | |
| 9568 pNext*: pointer | |
| 9569 identifierSize*: uint32 | |
| 9570 pIdentifier*: ptr uint8 | |
| 9571 VkShaderModuleIdentifierEXT* = object | |
| 9572 sType*: VkStructureType | |
| 9573 pNext*: pointer | |
| 9574 identifierSize*: uint32 | |
| 9575 identifier*: array[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT, uint8] | |
| 9576 VkImageCompressionControlEXT* = object | |
| 9577 sType*: VkStructureType | |
| 9578 pNext*: pointer | |
| 9579 flags*: VkImageCompressionFlagsEXT | |
| 9580 compressionControlPlaneCount*: uint32 | |
| 9581 pFixedRateFlags*: ptr VkImageCompressionFixedRateFlagsEXT | |
| 9582 VkPhysicalDeviceImageCompressionControlFeaturesEXT* = object | |
| 9583 sType*: VkStructureType | |
| 9584 pNext*: pointer | |
| 9585 imageCompressionControl*: VkBool32 | |
| 9586 VkImageCompressionPropertiesEXT* = object | |
| 9587 sType*: VkStructureType | |
| 9588 pNext*: pointer | |
| 9589 imageCompressionFlags*: VkImageCompressionFlagsEXT | |
| 9590 imageCompressionFixedRateFlags*: VkImageCompressionFixedRateFlagsEXT | |
| 9591 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* = object | |
| 9592 sType*: VkStructureType | |
| 9593 pNext*: pointer | |
| 9594 imageCompressionControlSwapchain*: VkBool32 | |
| 9595 VkImageSubresource2EXT* = object | |
| 9596 sType*: VkStructureType | |
| 9597 pNext*: pointer | |
| 9598 imageSubresource*: VkImageSubresource | |
| 9599 VkSubresourceLayout2EXT* = object | |
| 9600 sType*: VkStructureType | |
| 9601 pNext*: pointer | |
| 9602 subresourceLayout*: VkSubresourceLayout | |
| 9603 VkRenderPassCreationControlEXT* = object | |
| 9604 sType*: VkStructureType | |
| 9605 pNext*: pointer | |
| 9606 disallowMerging*: VkBool32 | |
| 9607 VkRenderPassCreationFeedbackInfoEXT* = object | |
| 9608 postMergeSubpassCount*: uint32 | |
| 9609 VkRenderPassCreationFeedbackCreateInfoEXT* = object | |
| 9610 sType*: VkStructureType | |
| 9611 pNext*: pointer | |
| 9612 pRenderPassFeedback*: ptr VkRenderPassCreationFeedbackInfoEXT | |
| 9613 VkRenderPassSubpassFeedbackInfoEXT* = object | |
| 9614 subpassMergeStatus*: VkSubpassMergeStatusEXT | |
| 9615 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 9616 postMergeIndex*: uint32 | |
| 9617 VkRenderPassSubpassFeedbackCreateInfoEXT* = object | |
| 9618 sType*: VkStructureType | |
| 9619 pNext*: pointer | |
| 9620 pSubpassFeedback*: ptr VkRenderPassSubpassFeedbackInfoEXT | |
| 9621 VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* = object | |
| 9622 sType*: VkStructureType | |
| 9623 pNext*: pointer | |
| 9624 subpassMergeFeedback*: VkBool32 | |
| 9625 VkMicromapBuildInfoEXT* = object | |
| 9626 sType*: VkStructureType | |
| 9627 pNext*: pointer | |
| 9628 thetype*: VkMicromapTypeEXT | |
| 9629 flags*: VkBuildMicromapFlagsEXT | |
| 9630 mode*: VkBuildMicromapModeEXT | |
| 9631 dstMicromap*: VkMicromapEXT | |
| 9632 usageCountsCount*: uint32 | |
| 9633 pUsageCounts*: ptr VkMicromapUsageEXT | |
| 9634 ppUsageCounts*: ptr ptr VkMicromapUsageEXT | |
| 9635 data*: VkDeviceOrHostAddressConstKHR | |
| 9636 scratchData*: VkDeviceOrHostAddressKHR | |
| 9637 triangleArray*: VkDeviceOrHostAddressConstKHR | |
| 9638 triangleArrayStride*: VkDeviceSize | |
| 9639 VkMicromapCreateInfoEXT* = object | |
| 9640 sType*: VkStructureType | |
| 9641 pNext*: pointer | |
| 9642 createFlags*: VkMicromapCreateFlagsEXT | |
| 9643 buffer*: VkBuffer | |
| 9644 offset*: VkDeviceSize | |
| 9645 size*: VkDeviceSize | |
| 9646 thetype*: VkMicromapTypeEXT | |
| 9647 deviceAddress*: VkDeviceAddress | |
| 9648 VkMicromapVersionInfoEXT* = object | |
| 9649 sType*: VkStructureType | |
| 9650 pNext*: pointer | |
| 9651 pVersionData*: ptr uint8 | |
| 9652 VkCopyMicromapInfoEXT* = object | |
| 9653 sType*: VkStructureType | |
| 9654 pNext*: pointer | |
| 9655 src*: VkMicromapEXT | |
| 9656 dst*: VkMicromapEXT | |
| 9657 mode*: VkCopyMicromapModeEXT | |
| 9658 VkCopyMicromapToMemoryInfoEXT* = object | |
| 9659 sType*: VkStructureType | |
| 9660 pNext*: pointer | |
| 9661 src*: VkMicromapEXT | |
| 9662 dst*: VkDeviceOrHostAddressKHR | |
| 9663 mode*: VkCopyMicromapModeEXT | |
| 9664 VkCopyMemoryToMicromapInfoEXT* = object | |
| 9665 sType*: VkStructureType | |
| 9666 pNext*: pointer | |
| 9667 src*: VkDeviceOrHostAddressConstKHR | |
| 9668 dst*: VkMicromapEXT | |
| 9669 mode*: VkCopyMicromapModeEXT | |
| 9670 VkMicromapBuildSizesInfoEXT* = object | |
| 9671 sType*: VkStructureType | |
| 9672 pNext*: pointer | |
| 9673 micromapSize*: VkDeviceSize | |
| 9674 buildScratchSize*: VkDeviceSize | |
| 9675 discardable*: VkBool32 | |
| 9676 VkMicromapUsageEXT* = object | |
| 9677 count*: uint32 | |
| 9678 subdivisionLevel*: uint32 | |
| 9679 format*: uint32 | |
| 9680 VkMicromapTriangleEXT* = object | |
| 9681 dataOffset*: uint32 | |
| 9682 subdivisionLevel*: uint16 | |
| 9683 format*: uint16 | |
| 9684 VkPhysicalDeviceOpacityMicromapFeaturesEXT* = object | |
| 9685 sType*: VkStructureType | |
| 9686 pNext*: pointer | |
| 9687 micromap*: VkBool32 | |
| 9688 micromapCaptureReplay*: VkBool32 | |
| 9689 micromapHostCommands*: VkBool32 | |
| 9690 VkPhysicalDeviceOpacityMicromapPropertiesEXT* = object | |
| 9691 sType*: VkStructureType | |
| 9692 pNext*: pointer | |
| 9693 maxOpacity2StateSubdivisionLevel*: uint32 | |
| 9694 maxOpacity4StateSubdivisionLevel*: uint32 | |
| 9695 VkAccelerationStructureTrianglesOpacityMicromapEXT* = object | |
| 9696 sType*: VkStructureType | |
| 9697 pNext*: pointer | |
| 9698 indexType*: VkIndexType | |
| 9699 indexBuffer*: VkDeviceOrHostAddressConstKHR | |
| 9700 indexStride*: VkDeviceSize | |
| 9701 baseTriangle*: uint32 | |
| 9702 usageCountsCount*: uint32 | |
| 9703 pUsageCounts*: ptr VkMicromapUsageEXT | |
| 9704 ppUsageCounts*: ptr ptr VkMicromapUsageEXT | |
| 9705 micromap*: VkMicromapEXT | |
| 9706 VkPipelinePropertiesIdentifierEXT* = object | |
| 9707 sType*: VkStructureType | |
| 9708 pNext*: pointer | |
| 9709 pipelineIdentifier*: array[VK_UUID_SIZE, uint8] | |
| 9710 VkPhysicalDevicePipelinePropertiesFeaturesEXT* = object | |
| 9711 sType*: VkStructureType | |
| 9712 pNext*: pointer | |
| 9713 pipelinePropertiesIdentifier*: VkBool32 | |
| 9714 VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* = object | |
| 9715 sType*: VkStructureType | |
| 9716 pNext*: pointer | |
| 9717 shaderEarlyAndLateFragmentTests*: VkBool32 | |
| 9718 VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* = object | |
| 9719 sType*: VkStructureType | |
| 9720 pNext*: pointer | |
| 9721 nonSeamlessCubeMap*: VkBool32 | |
| 9722 VkPhysicalDevicePipelineRobustnessFeaturesEXT* = object | |
| 9723 sType*: VkStructureType | |
| 9724 pNext*: pointer | |
| 9725 pipelineRobustness*: VkBool32 | |
| 9726 VkPipelineRobustnessCreateInfoEXT* = object | |
| 9727 sType*: VkStructureType | |
| 9728 pNext*: pointer | |
| 9729 storageBuffers*: VkPipelineRobustnessBufferBehaviorEXT | |
| 9730 uniformBuffers*: VkPipelineRobustnessBufferBehaviorEXT | |
| 9731 vertexInputs*: VkPipelineRobustnessBufferBehaviorEXT | |
| 9732 images*: VkPipelineRobustnessImageBehaviorEXT | |
| 9733 VkPhysicalDevicePipelineRobustnessPropertiesEXT* = object | |
| 9734 sType*: VkStructureType | |
| 9735 pNext*: pointer | |
| 9736 defaultRobustnessStorageBuffers*: VkPipelineRobustnessBufferBehaviorEXT | |
| 9737 defaultRobustnessUniformBuffers*: VkPipelineRobustnessBufferBehaviorEXT | |
| 9738 defaultRobustnessVertexInputs*: VkPipelineRobustnessBufferBehaviorEXT | |
| 9739 defaultRobustnessImages*: VkPipelineRobustnessImageBehaviorEXT | |
| 9740 VkImageViewSampleWeightCreateInfoQCOM* = object | |
| 9741 sType*: VkStructureType | |
| 9742 pNext*: pointer | |
| 9743 filterCenter*: VkOffset2D | |
| 9744 filterSize*: VkExtent2D | |
| 9745 numPhases*: uint32 | |
| 9746 VkPhysicalDeviceImageProcessingFeaturesQCOM* = object | |
| 9747 sType*: VkStructureType | |
| 9748 pNext*: pointer | |
| 9749 textureSampleWeighted*: VkBool32 | |
| 9750 textureBoxFilter*: VkBool32 | |
| 9751 textureBlockMatch*: VkBool32 | |
| 9752 VkPhysicalDeviceImageProcessingPropertiesQCOM* = object | |
| 9753 sType*: VkStructureType | |
| 9754 pNext*: pointer | |
| 9755 maxWeightFilterPhases*: uint32 | |
| 9756 maxWeightFilterDimension*: VkExtent2D | |
| 9757 maxBlockMatchRegion*: VkExtent2D | |
| 9758 maxBoxFilterBlockSize*: VkExtent2D | |
| 9759 VkPhysicalDeviceTilePropertiesFeaturesQCOM* = object | |
| 9760 sType*: VkStructureType | |
| 9761 pNext*: pointer | |
| 9762 tileProperties*: VkBool32 | |
| 9763 VkTilePropertiesQCOM* = object | |
| 9764 sType*: VkStructureType | |
| 9765 pNext*: pointer | |
| 9766 tileSize*: VkExtent3D | |
| 9767 apronSize*: VkExtent2D | |
| 9768 origin*: VkOffset2D | |
| 9769 VkPhysicalDeviceAmigoProfilingFeaturesSEC* = object | |
| 9770 sType*: VkStructureType | |
| 9771 pNext*: pointer | |
| 9772 amigoProfiling*: VkBool32 | |
| 9773 VkAmigoProfilingSubmitInfoSEC* = object | |
| 9774 sType*: VkStructureType | |
| 9775 pNext*: pointer | |
| 9776 firstDrawTimestamp*: uint64 | |
| 9777 swapBufferTimestamp*: uint64 | |
| 9778 VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* = object | |
| 9779 sType*: VkStructureType | |
| 9780 pNext*: pointer | |
| 9781 attachmentFeedbackLoopLayout*: VkBool32 | |
| 9782 VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* = object | |
| 9783 sType*: VkStructureType | |
| 9784 pNext*: pointer | |
| 9785 depthClampZeroOne*: VkBool32 | |
| 9786 VkPhysicalDeviceAddressBindingReportFeaturesEXT* = object | |
| 9787 sType*: VkStructureType | |
| 9788 pNext*: pointer | |
| 9789 reportAddressBinding*: VkBool32 | |
| 9790 VkDeviceAddressBindingCallbackDataEXT* = object | |
| 9791 sType*: VkStructureType | |
| 9792 pNext*: pointer | |
| 9793 flags*: VkDeviceAddressBindingFlagsEXT | |
| 9794 baseAddress*: VkDeviceAddress | |
| 9795 size*: VkDeviceSize | |
| 9796 bindingType*: VkDeviceAddressBindingTypeEXT | |
| 9797 VkPhysicalDeviceOpticalFlowFeaturesNV* = object | |
| 9798 sType*: VkStructureType | |
| 9799 pNext*: pointer | |
| 9800 opticalFlow*: VkBool32 | |
| 9801 VkPhysicalDeviceOpticalFlowPropertiesNV* = object | |
| 9802 sType*: VkStructureType | |
| 9803 pNext*: pointer | |
| 9804 supportedOutputGridSizes*: VkOpticalFlowGridSizeFlagsNV | |
| 9805 supportedHintGridSizes*: VkOpticalFlowGridSizeFlagsNV | |
| 9806 hintSupported*: VkBool32 | |
| 9807 costSupported*: VkBool32 | |
| 9808 bidirectionalFlowSupported*: VkBool32 | |
| 9809 globalFlowSupported*: VkBool32 | |
| 9810 minWidth*: uint32 | |
| 9811 minHeight*: uint32 | |
| 9812 maxWidth*: uint32 | |
| 9813 maxHeight*: uint32 | |
| 9814 maxNumRegionsOfInterest*: uint32 | |
| 9815 VkOpticalFlowImageFormatInfoNV* = object | |
| 9816 sType*: VkStructureType | |
| 9817 pNext*: pointer | |
| 9818 usage*: VkOpticalFlowUsageFlagsNV | |
| 9819 VkOpticalFlowImageFormatPropertiesNV* = object | |
| 9820 sType*: VkStructureType | |
| 9821 pNext*: pointer | |
| 9822 format*: VkFormat | |
| 9823 VkOpticalFlowSessionCreateInfoNV* = object | |
| 9824 sType*: VkStructureType | |
| 9825 pNext*: pointer | |
| 9826 width*: uint32 | |
| 9827 height*: uint32 | |
| 9828 imageFormat*: VkFormat | |
| 9829 flowVectorFormat*: VkFormat | |
| 9830 costFormat*: VkFormat | |
| 9831 outputGridSize*: VkOpticalFlowGridSizeFlagsNV | |
| 9832 hintGridSize*: VkOpticalFlowGridSizeFlagsNV | |
| 9833 performanceLevel*: VkOpticalFlowPerformanceLevelNV | |
| 9834 flags*: VkOpticalFlowSessionCreateFlagsNV | |
| 9835 VkOpticalFlowSessionCreatePrivateDataInfoNV* = object | |
| 9836 sType*: VkStructureType | |
| 9837 pNext*: pointer | |
| 9838 id*: uint32 | |
| 9839 size*: uint32 | |
| 9840 pPrivateData*: pointer | |
| 9841 VkOpticalFlowExecuteInfoNV* = object | |
| 9842 sType*: VkStructureType | |
| 9843 pNext*: pointer | |
| 9844 flags*: VkOpticalFlowExecuteFlagsNV | |
| 9845 regionCount*: uint32 | |
| 9846 pRegions*: ptr VkRect2D | |
| 9847 VkPhysicalDeviceFaultFeaturesEXT* = object | |
| 9848 sType*: VkStructureType | |
| 9849 pNext*: pointer | |
| 9850 deviceFault*: VkBool32 | |
| 9851 deviceFaultVendorBinary*: VkBool32 | |
| 9852 VkDeviceFaultAddressInfoEXT* = object | |
| 9853 addressType*: VkDeviceFaultAddressTypeEXT | |
| 9854 reportedAddress*: VkDeviceAddress | |
| 9855 addressPrecision*: VkDeviceSize | |
| 9856 VkDeviceFaultVendorInfoEXT* = object | |
| 9857 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 9858 vendorFaultCode*: uint64 | |
| 9859 vendorFaultData*: uint64 | |
| 9860 VkDeviceFaultCountsEXT* = object | |
| 9861 sType*: VkStructureType | |
| 9862 pNext*: pointer | |
| 9863 addressInfoCount*: uint32 | |
| 9864 vendorInfoCount*: uint32 | |
| 9865 vendorBinarySize*: VkDeviceSize | |
| 9866 VkDeviceFaultInfoEXT* = object | |
| 9867 sType*: VkStructureType | |
| 9868 pNext*: pointer | |
| 9869 description*: array[VK_MAX_DESCRIPTION_SIZE, char] | |
| 9870 pAddressInfos*: ptr VkDeviceFaultAddressInfoEXT | |
| 9871 pVendorInfos*: ptr VkDeviceFaultVendorInfoEXT | |
| 9872 pVendorBinaryData*: pointer | |
| 9873 VkDeviceFaultVendorBinaryHeaderVersionOneEXT* = object | |
| 9874 headerSize*: uint32 | |
| 9875 headerVersion*: VkDeviceFaultVendorBinaryHeaderVersionEXT | |
| 9876 vendorID*: uint32 | |
| 9877 deviceID*: uint32 | |
| 9878 driverVersion*: uint32 | |
| 9879 pipelineCacheUUID*: array[VK_UUID_SIZE, uint8] | |
| 9880 applicationNameOffset*: uint32 | |
| 9881 applicationVersion*: uint32 | |
| 9882 engineNameOffset*: uint32 | |
| 9883 VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* = object | |
| 9884 sType*: VkStructureType | |
| 9885 pNext*: pointer | |
| 9886 pipelineLibraryGroupHandles*: VkBool32 | |
| 9887 VkDecompressMemoryRegionNV* = object | |
| 9888 srcAddress*: VkDeviceAddress | |
| 9889 dstAddress*: VkDeviceAddress | |
| 9890 compressedSize*: VkDeviceSize | |
| 9891 decompressedSize*: VkDeviceSize | |
| 9892 decompressionMethod*: VkMemoryDecompressionMethodFlagsNV | |
| 9893 VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* = object | |
| 9894 sType*: VkStructureType | |
| 9895 pNext*: pointer | |
| 9896 shaderCoreMask*: uint64 | |
| 9897 shaderCoreCount*: uint32 | |
| 9898 shaderWarpsPerCore*: uint32 | |
| 9899 VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* = object | |
| 9900 sType*: VkStructureType | |
| 9901 pNext*: pointer | |
| 9902 shaderCoreBuiltins*: VkBool32 | |
| 9903 VkSurfacePresentModeEXT* = object | |
| 9904 sType*: VkStructureType | |
| 9905 pNext*: pointer | |
| 9906 presentMode*: VkPresentModeKHR | |
| 9907 VkSurfacePresentScalingCapabilitiesEXT* = object | |
| 9908 sType*: VkStructureType | |
| 9909 pNext*: pointer | |
| 9910 supportedPresentScaling*: VkPresentScalingFlagsEXT | |
| 9911 supportedPresentGravityX*: VkPresentGravityFlagsEXT | |
| 9912 supportedPresentGravityY*: VkPresentGravityFlagsEXT | |
| 9913 minScaledImageExtent*: VkExtent2D | |
| 9914 maxScaledImageExtent*: VkExtent2D | |
| 9915 VkSurfacePresentModeCompatibilityEXT* = object | |
| 9916 sType*: VkStructureType | |
| 9917 pNext*: pointer | |
| 9918 presentModeCount*: uint32 | |
| 9919 pPresentModes*: ptr VkPresentModeKHR | |
| 9920 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* = object | |
| 9921 sType*: VkStructureType | |
| 9922 pNext*: pointer | |
| 9923 swapchainMaintenance1*: VkBool32 | |
| 9924 VkSwapchainPresentFenceInfoEXT* = object | |
| 9925 sType*: VkStructureType | |
| 9926 pNext*: pointer | |
| 9927 swapchainCount*: uint32 | |
| 9928 pFences*: ptr VkFence | |
| 9929 VkSwapchainPresentModesCreateInfoEXT* = object | |
| 9930 sType*: VkStructureType | |
| 9931 pNext*: pointer | |
| 9932 presentModeCount*: uint32 | |
| 9933 pPresentModes*: ptr VkPresentModeKHR | |
| 9934 VkSwapchainPresentModeInfoEXT* = object | |
| 9935 sType*: VkStructureType | |
| 9936 pNext*: pointer | |
| 9937 swapchainCount*: uint32 | |
| 9938 pPresentModes*: ptr VkPresentModeKHR | |
| 9939 VkSwapchainPresentScalingCreateInfoEXT* = object | |
| 9940 sType*: VkStructureType | |
| 9941 pNext*: pointer | |
| 9942 scalingBehavior*: VkPresentScalingFlagsEXT | |
| 9943 presentGravityX*: VkPresentGravityFlagsEXT | |
| 9944 presentGravityY*: VkPresentGravityFlagsEXT | |
| 9945 VkReleaseSwapchainImagesInfoEXT* = object | |
| 9946 sType*: VkStructureType | |
| 9947 pNext*: pointer | |
| 9948 swapchain*: VkSwapchainKHR | |
| 9949 imageIndexCount*: uint32 | |
| 9950 pImageIndices*: ptr uint32 | |
| 9951 VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* = object | |
| 9952 sType*: VkStructureType | |
| 9953 pNext*: pointer | |
| 9954 rayTracingInvocationReorder*: VkBool32 | |
| 9955 VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* = object | |
| 9956 sType*: VkStructureType | |
| 9957 pNext*: pointer | |
| 9958 rayTracingInvocationReorderReorderingHint*: VkRayTracingInvocationReorderModeNV | |
| 9959 VkDirectDriverLoadingInfoLUNARG* = object | |
| 9960 sType*: VkStructureType | |
| 9961 pNext*: pointer | |
| 9962 flags*: VkDirectDriverLoadingFlagsLUNARG | |
| 9963 pfnGetInstanceProcAddr*: PFN_vkGetInstanceProcAddrLUNARG | |
| 9964 VkDirectDriverLoadingListLUNARG* = object | |
| 9965 sType*: VkStructureType | |
| 9966 pNext*: pointer | |
| 9967 mode*: VkDirectDriverLoadingModeLUNARG | |
| 9968 driverCount*: uint32 | |
| 9969 pDrivers*: ptr VkDirectDriverLoadingInfoLUNARG | |
| 9970 VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* = object | |
| 9971 sType*: VkStructureType | |
| 9972 pNext*: pointer | |
| 9973 multiviewPerViewViewports*: VkBool32 | |
| 9974 VkPhysicalDeviceShaderCorePropertiesARM* = object | |
| 9975 sType*: VkStructureType | |
| 9976 pNext*: pointer | |
| 9977 pixelRate*: uint32 | |
| 9978 texelRate*: uint32 | |
| 9979 fmaRate*: uint32 | |
| 9980 VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* = object | |
| 9981 sType*: VkStructureType | |
| 9982 pNext*: pointer | |
| 9983 multiviewPerViewRenderAreas*: VkBool32 | |
| 9984 VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* = object | |
| 9985 sType*: VkStructureType | |
| 9986 pNext*: pointer | |
| 9987 perViewRenderAreaCount*: uint32 | |
| 9988 pPerViewRenderAreas*: ptr VkRect2D | |
| 9989 # feature VK_VERSION_1_0 | |
| 9990 var | |
| 9991 vkCreateInstance*: proc(pCreateInfo: ptr VkInstanceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pInstance: ptr VkInstance): VkResult {.stdcall.} | |
| 9992 vkDestroyInstance*: proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 9993 vkEnumeratePhysicalDevices*: proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32, pPhysicalDevices: ptr VkPhysicalDevice): VkResult {.stdcall.} | |
| 9994 vkGetPhysicalDeviceFeatures*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures): void {.stdcall.} | |
| 9995 vkGetPhysicalDeviceFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties): void {.stdcall.} | |
| 9996 vkGetPhysicalDeviceImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties): VkResult {.stdcall.} | |
| 9997 vkGetPhysicalDeviceProperties*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties): void {.stdcall.} | |
| 9998 vkGetPhysicalDeviceQueueFamilyProperties*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties): void {.stdcall.} | |
| 9999 vkGetPhysicalDeviceMemoryProperties*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties): void {.stdcall.} | |
| 10000 vkGetDeviceProcAddr*: proc(device: VkDevice, pName: cstring): PFN_vkVoidFunction {.stdcall.} | |
| 10001 vkCreateDevice*: proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDevice: ptr VkDevice): VkResult {.stdcall.} | |
| 10002 vkDestroyDevice*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10003 vkEnumerateInstanceExtensionProperties*: proc(pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.} | |
| 10004 vkEnumerateDeviceExtensionProperties*: proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.} | |
| 10005 vkEnumerateInstanceLayerProperties*: proc(pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.} | |
| 10006 vkEnumerateDeviceLayerProperties*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.} | |
| 10007 vkGetDeviceQueue*: proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue): void {.stdcall.} | |
| 10008 vkQueueSubmit*: proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo, fence: VkFence): VkResult {.stdcall.} | |
| 10009 vkQueueWaitIdle*: proc(queue: VkQueue): VkResult {.stdcall.} | |
| 10010 vkDeviceWaitIdle*: proc(device: VkDevice): VkResult {.stdcall.} | |
| 10011 vkAllocateMemory*: proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo, pAllocator: ptr VkAllocationCallbacks, pMemory: ptr VkDeviceMemory): VkResult {.stdcall.} | |
| 10012 vkFreeMemory*: proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10013 vkMapMemory*: proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer): VkResult {.stdcall.} | |
| 10014 vkUnmapMemory*: proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.} | |
| 10015 vkFlushMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.} | |
| 10016 vkInvalidateMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.} | |
| 10017 vkGetDeviceMemoryCommitment*: proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize): void {.stdcall.} | |
| 10018 vkBindBufferMemory*: proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.} | |
| 10019 vkBindImageMemory*: proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.} | |
| 10020 vkGetBufferMemoryRequirements*: proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.} | |
| 10021 vkGetImageMemoryRequirements*: proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.} | |
| 10022 vkGetImageSparseMemoryRequirements*: proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements): void {.stdcall.} | |
| 10023 vkGetPhysicalDeviceSparseImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties): void {.stdcall.} | |
| 10024 vkQueueBindSparse*: proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo, fence: VkFence): VkResult {.stdcall.} | |
| 10025 vkCreateFence*: proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.} | |
| 10026 vkDestroyFence*: proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10027 vkResetFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence): VkResult {.stdcall.} | |
| 10028 vkGetFenceStatus*: proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.} | |
| 10029 vkWaitForFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence, waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.} | |
| 10030 vkCreateSemaphore*: proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSemaphore: ptr VkSemaphore): VkResult {.stdcall.} | |
| 10031 vkDestroySemaphore*: proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10032 vkCreateEvent*: proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo, pAllocator: ptr VkAllocationCallbacks, pEvent: ptr VkEvent): VkResult {.stdcall.} | |
| 10033 vkDestroyEvent*: proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10034 vkGetEventStatus*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.} | |
| 10035 vkSetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.} | |
| 10036 vkResetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.} | |
| 10037 vkCreateQueryPool*: proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pQueryPool: ptr VkQueryPool): VkResult {.stdcall.} | |
| 10038 vkDestroyQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10039 vkGetQueryPoolResults*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: csize_t, pData: pointer, stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.} | |
| 10040 vkCreateBuffer*: proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pBuffer: ptr VkBuffer): VkResult {.stdcall.} | |
| 10041 vkDestroyBuffer*: proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10042 vkCreateBufferView*: proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkBufferView): VkResult {.stdcall.} | |
| 10043 vkDestroyBufferView*: proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10044 vkCreateImage*: proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo, pAllocator: ptr VkAllocationCallbacks, pImage: ptr VkImage): VkResult {.stdcall.} | |
| 10045 vkDestroyImage*: proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10046 vkGetImageSubresourceLayout*: proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource, pLayout: ptr VkSubresourceLayout): void {.stdcall.} | |
| 10047 vkCreateImageView*: proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkImageView): VkResult {.stdcall.} | |
| 10048 vkDestroyImageView*: proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10049 vkCreateShaderModule*: proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pAllocator: ptr VkAllocationCallbacks, pShaderModule: ptr VkShaderModule): VkResult {.stdcall.} | |
| 10050 vkDestroyShaderModule*: proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10051 vkCreatePipelineCache*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineCache: ptr VkPipelineCache): VkResult {.stdcall.} | |
| 10052 vkDestroyPipelineCache*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10053 vkGetPipelineCacheData*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.} | |
| 10054 vkMergePipelineCaches*: proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache): VkResult {.stdcall.} | |
| 10055 vkCreateGraphicsPipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.} | |
| 10056 vkCreateComputePipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.} | |
| 10057 vkDestroyPipeline*: proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10058 vkCreatePipelineLayout*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineLayout: ptr VkPipelineLayout): VkResult {.stdcall.} | |
| 10059 vkDestroyPipelineLayout*: proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10060 vkCreateSampler*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSampler: ptr VkSampler): VkResult {.stdcall.} | |
| 10061 vkDestroySampler*: proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10062 vkCreateDescriptorSetLayout*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSetLayout: ptr VkDescriptorSetLayout): VkResult {.stdcall.} | |
| 10063 vkDestroyDescriptorSetLayout*: proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10064 vkCreateDescriptorPool*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorPool: ptr VkDescriptorPool): VkResult {.stdcall.} | |
| 10065 vkDestroyDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10066 vkResetDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.} | |
| 10067 vkAllocateDescriptorSets*: proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.} | |
| 10068 vkFreeDescriptorSets*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.} | |
| 10069 vkUpdateDescriptorSets*: proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet, descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet): void {.stdcall.} | |
| 10070 vkCreateFramebuffer*: proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFramebuffer: ptr VkFramebuffer): VkResult {.stdcall.} | |
| 10071 vkDestroyFramebuffer*: proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10072 vkCreateRenderPass*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.} | |
| 10073 vkDestroyRenderPass*: proc(device: VkDevice, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10074 vkGetRenderAreaGranularity*: proc(device: VkDevice, renderPass: VkRenderPass, pGranularity: ptr VkExtent2D): void {.stdcall.} | |
| 10075 vkCreateCommandPool*: proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pCommandPool: ptr VkCommandPool): VkResult {.stdcall.} | |
| 10076 vkDestroyCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10077 vkResetCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.} | |
| 10078 vkAllocateCommandBuffers*: proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo, pCommandBuffers: ptr VkCommandBuffer): VkResult {.stdcall.} | |
| 10079 vkFreeCommandBuffers*: proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.} | |
| 10080 vkBeginCommandBuffer*: proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo): VkResult {.stdcall.} | |
| 10081 vkEndCommandBuffer*: proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.} | |
| 10082 vkResetCommandBuffer*: proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.} | |
| 10083 vkCmdBindPipeline*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.} | |
| 10084 vkCmdSetViewport*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.} | |
| 10085 vkCmdSetScissor*: proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.} | |
| 10086 vkCmdSetLineWidth*: proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.} | |
| 10087 vkCmdSetDepthBias*: proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.} | |
| 10088 vkCmdSetBlendConstants*: proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.} | |
| 10089 vkCmdSetDepthBounds*: proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.} | |
| 10090 vkCmdSetStencilCompareMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.} | |
| 10091 vkCmdSetStencilWriteMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.} | |
| 10092 vkCmdSetStencilReference*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.} | |
| 10093 vkCmdBindDescriptorSets*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet, dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32): void {.stdcall.} | |
| 10094 vkCmdBindIndexBuffer*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.} | |
| 10095 vkCmdBindVertexBuffers*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize): void {.stdcall.} | |
| 10096 vkCmdDraw*: proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.} | |
| 10097 vkCmdDrawIndexed*: proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.} | |
| 10098 vkCmdDrawIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10099 vkCmdDrawIndexedIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10100 vkCmdDispatch*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.} | |
| 10101 vkCmdDispatchIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.} | |
| 10102 vkCmdCopyBuffer*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy): void {.stdcall.} | |
| 10103 vkCmdCopyImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy): void {.stdcall.} | |
| 10104 vkCmdBlitImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit, filter: VkFilter): void {.stdcall.} | |
| 10105 vkCmdCopyBufferToImage*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.} | |
| 10106 vkCmdCopyImageToBuffer*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.} | |
| 10107 vkCmdUpdateBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer): void {.stdcall.} | |
| 10108 vkCmdFillBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.} | |
| 10109 vkCmdClearColorImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.} | |
| 10110 vkCmdClearDepthStencilImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.} | |
| 10111 vkCmdClearAttachments*: proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment, rectCount: uint32, pRects: ptr VkClearRect): void {.stdcall.} | |
| 10112 vkCmdResolveImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve): void {.stdcall.} | |
| 10113 vkCmdSetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.} | |
| 10114 vkCmdResetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.} | |
| 10115 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.} | |
| 10116 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.} | |
| 10117 vkCmdBeginQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.} | |
| 10118 vkCmdEndQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.} | |
| 10119 vkCmdResetQueryPool*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.} | |
| 10120 vkCmdWriteTimestamp*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.} | |
| 10121 vkCmdCopyQueryPoolResults*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.} | |
| 10122 vkCmdPushConstants*: proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer): void {.stdcall.} | |
| 10123 vkCmdBeginRenderPass*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, contents: VkSubpassContents): void {.stdcall.} | |
| 10124 vkCmdNextSubpass*: proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.} | |
| 10125 vkCmdEndRenderPass*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.} | |
| 10126 vkCmdExecuteCommands*: proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.} | |
| 10127 proc loadVK_VERSION_1_0*(instance: VkInstance) = | |
| 10128 vkDestroyInstance = cast[proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyInstance")) | |
| 10129 vkEnumeratePhysicalDevices = cast[proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32, pPhysicalDevices: ptr VkPhysicalDevice): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices")) | |
| 10130 vkGetPhysicalDeviceFeatures = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures")) | |
| 10131 vkGetPhysicalDeviceFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties")) | |
| 10132 vkGetPhysicalDeviceImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties")) | |
| 10133 vkGetPhysicalDeviceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties")) | |
| 10134 vkGetPhysicalDeviceQueueFamilyProperties = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties")) | |
| 10135 vkGetPhysicalDeviceMemoryProperties = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties")) | |
| 10136 vkGetDeviceProcAddr = cast[proc(device: VkDevice, pName: cstring): PFN_vkVoidFunction {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr")) | |
| 10137 vkCreateDevice = cast[proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDevice: ptr VkDevice): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDevice")) | |
| 10138 vkDestroyDevice = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDevice")) | |
| 10139 vkEnumerateDeviceExtensionProperties = cast[proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties")) | |
| 10140 vkEnumerateDeviceLayerProperties = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties")) | |
| 10141 vkGetDeviceQueue = cast[proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceQueue")) | |
| 10142 vkQueueSubmit = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueSubmit")) | |
| 10143 vkQueueWaitIdle = cast[proc(queue: VkQueue): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueWaitIdle")) | |
| 10144 vkDeviceWaitIdle = cast[proc(device: VkDevice): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDeviceWaitIdle")) | |
| 10145 vkAllocateMemory = cast[proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo, pAllocator: ptr VkAllocationCallbacks, pMemory: ptr VkDeviceMemory): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAllocateMemory")) | |
| 10146 vkFreeMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFreeMemory")) | |
| 10147 vkMapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkMapMemory")) | |
| 10148 vkUnmapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUnmapMemory")) | |
| 10149 vkFlushMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges")) | |
| 10150 vkInvalidateMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges")) | |
| 10151 vkGetDeviceMemoryCommitment = cast[proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment")) | |
| 10152 vkBindBufferMemory = cast[proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindBufferMemory")) | |
| 10153 vkBindImageMemory = cast[proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindImageMemory")) | |
| 10154 vkGetBufferMemoryRequirements = cast[proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements")) | |
| 10155 vkGetImageMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements")) | |
| 10156 vkGetImageSparseMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements")) | |
| 10157 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")) | |
| 10158 vkQueueBindSparse = cast[proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueBindSparse")) | |
| 10159 vkCreateFence = cast[proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateFence")) | |
| 10160 vkDestroyFence = cast[proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyFence")) | |
| 10161 vkResetFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetFences")) | |
| 10162 vkGetFenceStatus = cast[proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetFenceStatus")) | |
| 10163 vkWaitForFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence, waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWaitForFences")) | |
| 10164 vkCreateSemaphore = cast[proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSemaphore: ptr VkSemaphore): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSemaphore")) | |
| 10165 vkDestroySemaphore = cast[proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySemaphore")) | |
| 10166 vkCreateEvent = cast[proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo, pAllocator: ptr VkAllocationCallbacks, pEvent: ptr VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateEvent")) | |
| 10167 vkDestroyEvent = cast[proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyEvent")) | |
| 10168 vkGetEventStatus = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetEventStatus")) | |
| 10169 vkSetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetEvent")) | |
| 10170 vkResetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetEvent")) | |
| 10171 vkCreateQueryPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pQueryPool: ptr VkQueryPool): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateQueryPool")) | |
| 10172 vkDestroyQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyQueryPool")) | |
| 10173 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")) | |
| 10174 vkCreateBuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pBuffer: ptr VkBuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateBuffer")) | |
| 10175 vkDestroyBuffer = cast[proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyBuffer")) | |
| 10176 vkCreateBufferView = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkBufferView): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateBufferView")) | |
| 10177 vkDestroyBufferView = cast[proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyBufferView")) | |
| 10178 vkCreateImage = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo, pAllocator: ptr VkAllocationCallbacks, pImage: ptr VkImage): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateImage")) | |
| 10179 vkDestroyImage = cast[proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyImage")) | |
| 10180 vkGetImageSubresourceLayout = cast[proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource, pLayout: ptr VkSubresourceLayout): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout")) | |
| 10181 vkCreateImageView = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo, pAllocator: ptr VkAllocationCallbacks, pView: ptr VkImageView): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateImageView")) | |
| 10182 vkDestroyImageView = cast[proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyImageView")) | |
| 10183 vkCreateShaderModule = cast[proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pAllocator: ptr VkAllocationCallbacks, pShaderModule: ptr VkShaderModule): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateShaderModule")) | |
| 10184 vkDestroyShaderModule = cast[proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyShaderModule")) | |
| 10185 vkCreatePipelineCache = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineCache: ptr VkPipelineCache): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreatePipelineCache")) | |
| 10186 vkDestroyPipelineCache = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPipelineCache")) | |
| 10187 vkGetPipelineCacheData = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineCacheData")) | |
| 10188 vkMergePipelineCaches = cast[proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkMergePipelineCaches")) | |
| 10189 vkCreateGraphicsPipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateGraphicsPipelines")) | |
| 10190 vkCreateComputePipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateComputePipelines")) | |
| 10191 vkDestroyPipeline = cast[proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPipeline")) | |
| 10192 vkCreatePipelineLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPipelineLayout: ptr VkPipelineLayout): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreatePipelineLayout")) | |
| 10193 vkDestroyPipelineLayout = cast[proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPipelineLayout")) | |
| 10194 vkCreateSampler = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSampler: ptr VkSampler): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSampler")) | |
| 10195 vkDestroySampler = cast[proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySampler")) | |
| 10196 vkCreateDescriptorSetLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pAllocator: ptr VkAllocationCallbacks, pSetLayout: ptr VkDescriptorSetLayout): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout")) | |
| 10197 vkDestroyDescriptorSetLayout = cast[proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout")) | |
| 10198 vkCreateDescriptorPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorPool: ptr VkDescriptorPool): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDescriptorPool")) | |
| 10199 vkDestroyDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDescriptorPool")) | |
| 10200 vkResetDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetDescriptorPool")) | |
| 10201 vkAllocateDescriptorSets = cast[proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAllocateDescriptorSets")) | |
| 10202 vkFreeDescriptorSets = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFreeDescriptorSets")) | |
| 10203 vkUpdateDescriptorSets = cast[proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet, descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSets")) | |
| 10204 vkCreateFramebuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo, pAllocator: ptr VkAllocationCallbacks, pFramebuffer: ptr VkFramebuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateFramebuffer")) | |
| 10205 vkDestroyFramebuffer = cast[proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyFramebuffer")) | |
| 10206 vkCreateRenderPass = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRenderPass")) | |
| 10207 vkDestroyRenderPass = cast[proc(device: VkDevice, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyRenderPass")) | |
| 10208 vkGetRenderAreaGranularity = cast[proc(device: VkDevice, renderPass: VkRenderPass, pGranularity: ptr VkExtent2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRenderAreaGranularity")) | |
| 10209 vkCreateCommandPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo, pAllocator: ptr VkAllocationCallbacks, pCommandPool: ptr VkCommandPool): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateCommandPool")) | |
| 10210 vkDestroyCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyCommandPool")) | |
| 10211 vkResetCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetCommandPool")) | |
| 10212 vkAllocateCommandBuffers = cast[proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo, pCommandBuffers: ptr VkCommandBuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAllocateCommandBuffers")) | |
| 10213 vkFreeCommandBuffers = cast[proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkFreeCommandBuffers")) | |
| 10214 vkBeginCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBeginCommandBuffer")) | |
| 10215 vkEndCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEndCommandBuffer")) | |
| 10216 vkResetCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetCommandBuffer")) | |
| 10217 vkCmdBindPipeline = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindPipeline")) | |
| 10218 vkCmdSetViewport = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewport")) | |
| 10219 vkCmdSetScissor = cast[proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetScissor")) | |
| 10220 vkCmdSetLineWidth = cast[proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineWidth")) | |
| 10221 vkCmdSetDepthBias = cast[proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBias")) | |
| 10222 vkCmdSetBlendConstants = cast[proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetBlendConstants")) | |
| 10223 vkCmdSetDepthBounds = cast[proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBounds")) | |
| 10224 vkCmdSetStencilCompareMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask")) | |
| 10225 vkCmdSetStencilWriteMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask")) | |
| 10226 vkCmdSetStencilReference = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilReference")) | |
| 10227 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")) | |
| 10228 vkCmdBindIndexBuffer = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindIndexBuffer")) | |
| 10229 vkCmdBindVertexBuffers = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers")) | |
| 10230 vkCmdDraw = cast[proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDraw")) | |
| 10231 vkCmdDrawIndexed = cast[proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndexed")) | |
| 10232 vkCmdDrawIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndirect")) | |
| 10233 vkCmdDrawIndexedIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect")) | |
| 10234 vkCmdDispatch = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDispatch")) | |
| 10235 vkCmdDispatchIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDispatchIndirect")) | |
| 10236 vkCmdCopyBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer")) | |
| 10237 vkCmdCopyImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImage")) | |
| 10238 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")) | |
| 10239 vkCmdCopyBufferToImage = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage")) | |
| 10240 vkCmdCopyImageToBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer")) | |
| 10241 vkCmdUpdateBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdUpdateBuffer")) | |
| 10242 vkCmdFillBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdFillBuffer")) | |
| 10243 vkCmdClearColorImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdClearColorImage")) | |
| 10244 vkCmdClearDepthStencilImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue, rangeCount: uint32, pRanges: ptr VkImageSubresourceRange): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage")) | |
| 10245 vkCmdClearAttachments = cast[proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment, rectCount: uint32, pRects: ptr VkClearRect): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdClearAttachments")) | |
| 10246 vkCmdResolveImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResolveImage")) | |
| 10247 vkCmdSetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetEvent")) | |
| 10248 vkCmdResetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResetEvent")) | |
| 10249 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")) | |
| 10250 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")) | |
| 10251 vkCmdBeginQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginQuery")) | |
| 10252 vkCmdEndQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndQuery")) | |
| 10253 vkCmdResetQueryPool = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResetQueryPool")) | |
| 10254 vkCmdWriteTimestamp = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp")) | |
| 10255 vkCmdCopyQueryPoolResults = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults")) | |
| 10256 vkCmdPushConstants = cast[proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushConstants")) | |
| 10257 vkCmdBeginRenderPass = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, contents: VkSubpassContents): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass")) | |
| 10258 vkCmdNextSubpass = cast[proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdNextSubpass")) | |
| 10259 vkCmdEndRenderPass = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass")) | |
| 10260 vkCmdExecuteCommands = cast[proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdExecuteCommands")) | |
| 10261 | |
| 10262 # feature VK_VERSION_1_1 | |
| 10263 var | |
| 10264 vkEnumerateInstanceVersion*: proc(pApiVersion: ptr uint32): VkResult {.stdcall.} | |
| 10265 vkBindBufferMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo): VkResult {.stdcall.} | |
| 10266 vkBindImageMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo): VkResult {.stdcall.} | |
| 10267 vkGetDeviceGroupPeerMemoryFeatures*: proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags): void {.stdcall.} | |
| 10268 vkCmdSetDeviceMask*: proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.} | |
| 10269 vkCmdDispatchBase*: proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.} | |
| 10270 vkEnumeratePhysicalDeviceGroups*: proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32, pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties): VkResult {.stdcall.} | |
| 10271 vkGetImageMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.} | |
| 10272 vkGetBufferMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.} | |
| 10273 vkGetImageSparseMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.} | |
| 10274 vkGetPhysicalDeviceFeatures2*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2): void {.stdcall.} | |
| 10275 vkGetPhysicalDeviceProperties2*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2): void {.stdcall.} | |
| 10276 vkGetPhysicalDeviceFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2): void {.stdcall.} | |
| 10277 vkGetPhysicalDeviceImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: ptr VkImageFormatProperties2): VkResult {.stdcall.} | |
| 10278 vkGetPhysicalDeviceQueueFamilyProperties2*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties2): void {.stdcall.} | |
| 10279 vkGetPhysicalDeviceMemoryProperties2*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2): void {.stdcall.} | |
| 10280 vkGetPhysicalDeviceSparseImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties2): void {.stdcall.} | |
| 10281 vkTrimCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.} | |
| 10282 vkGetDeviceQueue2*: proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2, pQueue: ptr VkQueue): void {.stdcall.} | |
| 10283 vkCreateSamplerYcbcrConversion*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo, pAllocator: ptr VkAllocationCallbacks, pYcbcrConversion: ptr VkSamplerYcbcrConversion): VkResult {.stdcall.} | |
| 10284 vkDestroySamplerYcbcrConversion*: proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10285 vkCreateDescriptorUpdateTemplate*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate): VkResult {.stdcall.} | |
| 10286 vkDestroyDescriptorUpdateTemplate*: proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10287 vkUpdateDescriptorSetWithTemplate*: proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer): void {.stdcall.} | |
| 10288 vkGetPhysicalDeviceExternalBufferProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ptr VkExternalBufferProperties): void {.stdcall.} | |
| 10289 vkGetPhysicalDeviceExternalFenceProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ptr VkExternalFenceProperties): void {.stdcall.} | |
| 10290 vkGetPhysicalDeviceExternalSemaphoreProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties): void {.stdcall.} | |
| 10291 vkGetDescriptorSetLayoutSupport*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pSupport: ptr VkDescriptorSetLayoutSupport): void {.stdcall.} | |
| 10292 proc loadVK_VERSION_1_1*(instance: VkInstance) = | |
| 10293 vkBindBufferMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindBufferMemory2")) | |
| 10294 vkBindImageMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindImageMemory2")) | |
| 10295 vkGetDeviceGroupPeerMemoryFeatures = cast[proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures")) | |
| 10296 vkCmdSetDeviceMask = cast[proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMask")) | |
| 10297 vkCmdDispatchBase = cast[proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDispatchBase")) | |
| 10298 vkEnumeratePhysicalDeviceGroups = cast[proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32, pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroups")) | |
| 10299 vkGetImageMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2")) | |
| 10300 vkGetBufferMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2")) | |
| 10301 vkGetImageSparseMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2")) | |
| 10302 vkGetPhysicalDeviceFeatures2 = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2")) | |
| 10303 vkGetPhysicalDeviceProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2")) | |
| 10304 vkGetPhysicalDeviceFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2")) | |
| 10305 vkGetPhysicalDeviceImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: ptr VkImageFormatProperties2): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2")) | |
| 10306 vkGetPhysicalDeviceQueueFamilyProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32, pQueueFamilyProperties: ptr VkQueueFamilyProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2")) | |
| 10307 vkGetPhysicalDeviceMemoryProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2")) | |
| 10308 vkGetPhysicalDeviceSparseImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: ptr uint32, pProperties: ptr VkSparseImageFormatProperties2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2")) | |
| 10309 vkTrimCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkTrimCommandPool")) | |
| 10310 vkGetDeviceQueue2 = cast[proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2, pQueue: ptr VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceQueue2")) | |
| 10311 vkCreateSamplerYcbcrConversion = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo, pAllocator: ptr VkAllocationCallbacks, pYcbcrConversion: ptr VkSamplerYcbcrConversion): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion")) | |
| 10312 vkDestroySamplerYcbcrConversion = cast[proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion")) | |
| 10313 vkCreateDescriptorUpdateTemplate = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo, pAllocator: ptr VkAllocationCallbacks, pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate")) | |
| 10314 vkDestroyDescriptorUpdateTemplate = cast[proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate")) | |
| 10315 vkUpdateDescriptorSetWithTemplate = cast[proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate")) | |
| 10316 vkGetPhysicalDeviceExternalBufferProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: ptr VkExternalBufferProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties")) | |
| 10317 vkGetPhysicalDeviceExternalFenceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: ptr VkExternalFenceProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties")) | |
| 10318 vkGetPhysicalDeviceExternalSemaphoreProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties")) | |
| 10319 vkGetDescriptorSetLayoutSupport = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo, pSupport: ptr VkDescriptorSetLayoutSupport): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport")) | |
| 10320 | |
| 10321 # feature VK_VERSION_1_2 | |
| 10322 var | |
| 10323 vkCmdDrawIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10324 vkCmdDrawIndexedIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10325 vkCreateRenderPass2*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.} | |
| 10326 vkCmdBeginRenderPass2*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, pSubpassBeginInfo: ptr VkSubpassBeginInfo): void {.stdcall.} | |
| 10327 vkCmdNextSubpass2*: proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.} | |
| 10328 vkCmdEndRenderPass2*: proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.} | |
| 10329 vkResetQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.} | |
| 10330 vkGetSemaphoreCounterValue*: proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64): VkResult {.stdcall.} | |
| 10331 vkWaitSemaphores*: proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo, timeout: uint64): VkResult {.stdcall.} | |
| 10332 vkSignalSemaphore*: proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo): VkResult {.stdcall.} | |
| 10333 vkGetBufferDeviceAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): VkDeviceAddress {.stdcall.} | |
| 10334 vkGetBufferOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): uint64 {.stdcall.} | |
| 10335 vkGetDeviceMemoryOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo): uint64 {.stdcall.} | |
| 10336 proc loadVK_VERSION_1_2*(instance: VkInstance) = | |
| 10337 vkCmdDrawIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCount")) | |
| 10338 vkCmdDrawIndexedIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount")) | |
| 10339 vkCreateRenderPass2 = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2, pAllocator: ptr VkAllocationCallbacks, pRenderPass: ptr VkRenderPass): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRenderPass2")) | |
| 10340 vkCmdBeginRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo, pSubpassBeginInfo: ptr VkSubpassBeginInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2")) | |
| 10341 vkCmdNextSubpass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2")) | |
| 10342 vkCmdEndRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2")) | |
| 10343 vkResetQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkResetQueryPool")) | |
| 10344 vkGetSemaphoreCounterValue = cast[proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue")) | |
| 10345 vkWaitSemaphores = cast[proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo, timeout: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWaitSemaphores")) | |
| 10346 vkSignalSemaphore = cast[proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSignalSemaphore")) | |
| 10347 vkGetBufferDeviceAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): VkDeviceAddress {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddress")) | |
| 10348 vkGetBufferOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): uint64 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress")) | |
| 10349 vkGetDeviceMemoryOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo): uint64 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddress")) | |
| 10350 | |
| 10351 # feature VK_VERSION_1_3 | |
| 10352 var | |
| 10353 vkGetPhysicalDeviceToolProperties*: proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32, pToolProperties: ptr VkPhysicalDeviceToolProperties): VkResult {.stdcall.} | |
| 10354 vkCreatePrivateDataSlot*: proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPrivateDataSlot: ptr VkPrivateDataSlot): VkResult {.stdcall.} | |
| 10355 vkDestroyPrivateDataSlot*: proc(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10356 vkSetPrivateData*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, data: uint64): VkResult {.stdcall.} | |
| 10357 vkGetPrivateData*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, pData: ptr uint64): void {.stdcall.} | |
| 10358 vkCmdSetEvent2*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.} | |
| 10359 vkCmdResetEvent2*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2): void {.stdcall.} | |
| 10360 vkCmdWaitEvents2*: proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent, pDependencyInfos: ptr VkDependencyInfo): void {.stdcall.} | |
| 10361 vkCmdPipelineBarrier2*: proc(commandBuffer: VkCommandBuffer, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.} | |
| 10362 vkCmdWriteTimestamp2*: proc(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32): void {.stdcall.} | |
| 10363 vkQueueSubmit2*: proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo2, fence: VkFence): VkResult {.stdcall.} | |
| 10364 vkCmdCopyBuffer2*: proc(commandBuffer: VkCommandBuffer, pCopyBufferInfo: ptr VkCopyBufferInfo2): void {.stdcall.} | |
| 10365 vkCmdCopyImage2*: proc(commandBuffer: VkCommandBuffer, pCopyImageInfo: ptr VkCopyImageInfo2): void {.stdcall.} | |
| 10366 vkCmdCopyBufferToImage2*: proc(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: ptr VkCopyBufferToImageInfo2): void {.stdcall.} | |
| 10367 vkCmdCopyImageToBuffer2*: proc(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: ptr VkCopyImageToBufferInfo2): void {.stdcall.} | |
| 10368 vkCmdBlitImage2*: proc(commandBuffer: VkCommandBuffer, pBlitImageInfo: ptr VkBlitImageInfo2): void {.stdcall.} | |
| 10369 vkCmdResolveImage2*: proc(commandBuffer: VkCommandBuffer, pResolveImageInfo: ptr VkResolveImageInfo2): void {.stdcall.} | |
| 10370 vkCmdBeginRendering*: proc(commandBuffer: VkCommandBuffer, pRenderingInfo: ptr VkRenderingInfo): void {.stdcall.} | |
| 10371 vkCmdEndRendering*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.} | |
| 10372 vkCmdSetCullMode*: proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.} | |
| 10373 vkCmdSetFrontFace*: proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.} | |
| 10374 vkCmdSetPrimitiveTopology*: proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.} | |
| 10375 vkCmdSetViewportWithCount*: proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.} | |
| 10376 vkCmdSetScissorWithCount*: proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.} | |
| 10377 vkCmdBindVertexBuffers2*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize, pStrides: ptr VkDeviceSize): void {.stdcall.} | |
| 10378 vkCmdSetDepthTestEnable*: proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.} | |
| 10379 vkCmdSetDepthWriteEnable*: proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.} | |
| 10380 vkCmdSetDepthCompareOp*: proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.} | |
| 10381 vkCmdSetDepthBoundsTestEnable*: proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.} | |
| 10382 vkCmdSetStencilTestEnable*: proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.} | |
| 10383 vkCmdSetStencilOp*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.} | |
| 10384 vkCmdSetRasterizerDiscardEnable*: proc(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32): void {.stdcall.} | |
| 10385 vkCmdSetDepthBiasEnable*: proc(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32): void {.stdcall.} | |
| 10386 vkCmdSetPrimitiveRestartEnable*: proc(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32): void {.stdcall.} | |
| 10387 vkGetDeviceBufferMemoryRequirements*: proc(device: VkDevice, pInfo: ptr VkDeviceBufferMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.} | |
| 10388 vkGetDeviceImageMemoryRequirements*: proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.} | |
| 10389 vkGetDeviceImageSparseMemoryRequirements*: proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.} | |
| 10390 proc loadVK_VERSION_1_3*(instance: VkInstance) = | |
| 10391 vkGetPhysicalDeviceToolProperties = cast[proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32, pToolProperties: ptr VkPhysicalDeviceToolProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolProperties")) | |
| 10392 vkCreatePrivateDataSlot = cast[proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfo, pAllocator: ptr VkAllocationCallbacks, pPrivateDataSlot: ptr VkPrivateDataSlot): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlot")) | |
| 10393 vkDestroyPrivateDataSlot = cast[proc(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyPrivateDataSlot")) | |
| 10394 vkSetPrivateData = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, data: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetPrivateData")) | |
| 10395 vkGetPrivateData = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlot, pData: ptr uint64): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPrivateData")) | |
| 10396 vkCmdSetEvent2 = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetEvent2")) | |
| 10397 vkCmdResetEvent2 = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResetEvent2")) | |
| 10398 vkCmdWaitEvents2 = cast[proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent, pDependencyInfos: ptr VkDependencyInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2")) | |
| 10399 vkCmdPipelineBarrier2 = cast[proc(commandBuffer: VkCommandBuffer, pDependencyInfo: ptr VkDependencyInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2")) | |
| 10400 vkCmdWriteTimestamp2 = cast[proc(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2")) | |
| 10401 vkQueueSubmit2 = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo2, fence: VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueSubmit2")) | |
| 10402 vkCmdCopyBuffer2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyBufferInfo: ptr VkCopyBufferInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2")) | |
| 10403 vkCmdCopyImage2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyImageInfo: ptr VkCopyImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImage2")) | |
| 10404 vkCmdCopyBufferToImage2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: ptr VkCopyBufferToImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2")) | |
| 10405 vkCmdCopyImageToBuffer2 = cast[proc(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: ptr VkCopyImageToBufferInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2")) | |
| 10406 vkCmdBlitImage2 = cast[proc(commandBuffer: VkCommandBuffer, pBlitImageInfo: ptr VkBlitImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBlitImage2")) | |
| 10407 vkCmdResolveImage2 = cast[proc(commandBuffer: VkCommandBuffer, pResolveImageInfo: ptr VkResolveImageInfo2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdResolveImage2")) | |
| 10408 vkCmdBeginRendering = cast[proc(commandBuffer: VkCommandBuffer, pRenderingInfo: ptr VkRenderingInfo): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginRendering")) | |
| 10409 vkCmdEndRendering = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndRendering")) | |
| 10410 vkCmdSetCullMode = cast[proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCullMode")) | |
| 10411 vkCmdSetFrontFace = cast[proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetFrontFace")) | |
| 10412 vkCmdSetPrimitiveTopology = cast[proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopology")) | |
| 10413 vkCmdSetViewportWithCount = cast[proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportWithCount")) | |
| 10414 vkCmdSetScissorWithCount = cast[proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetScissorWithCount")) | |
| 10415 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")) | |
| 10416 vkCmdSetDepthTestEnable = cast[proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable")) | |
| 10417 vkCmdSetDepthWriteEnable = cast[proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnable")) | |
| 10418 vkCmdSetDepthCompareOp = cast[proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp")) | |
| 10419 vkCmdSetDepthBoundsTestEnable = cast[proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnable")) | |
| 10420 vkCmdSetStencilTestEnable = cast[proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilTestEnable")) | |
| 10421 vkCmdSetStencilOp = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetStencilOp")) | |
| 10422 vkCmdSetRasterizerDiscardEnable = cast[proc(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnable")) | |
| 10423 vkCmdSetDepthBiasEnable = cast[proc(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable")) | |
| 10424 vkCmdSetPrimitiveRestartEnable = cast[proc(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnable")) | |
| 10425 vkGetDeviceBufferMemoryRequirements = cast[proc(device: VkDevice, pInfo: ptr VkDeviceBufferMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirements")) | |
| 10426 vkGetDeviceImageMemoryRequirements = cast[proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirements")) | |
| 10427 vkGetDeviceImageSparseMemoryRequirements = cast[proc(device: VkDevice, pInfo: ptr VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ptr uint32, pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirements")) | |
| 10428 | |
| 10429 | |
| 10430 proc loadVulkan*(instance: VkInstance) = | |
| 10431 loadVK_VERSION_1_0(instance) | |
| 10432 loadVK_VERSION_1_1(instance) | |
| 10433 loadVK_VERSION_1_2(instance) | |
| 10434 loadVK_VERSION_1_3(instance) | |
| 10435 | |
| 10436 proc loadVK_NV_geometry_shader_passthrough*(instance: VkInstance) = | |
| 10437 discard | |
| 10438 | |
| 10439 proc loadVK_EXT_rasterization_order_attachment_access*(instance: VkInstance) = | |
| 10440 loadVK_VERSION_1_1(instance) | |
| 10441 | |
| 10442 proc loadVK_IMG_format_pvrtc*(instance: VkInstance) = | |
| 10443 discard | |
| 10444 | |
| 10445 proc loadVK_AMD_shader_fragment_mask*(instance: VkInstance) = | |
| 10446 discard | |
| 10447 | |
| 10448 proc loadVK_EXT_primitive_topology_list_restart*(instance: VkInstance) = | |
| 10449 loadVK_VERSION_1_1(instance) | |
| 10450 | |
| 10451 proc loadVK_KHR_global_priority*(instance: VkInstance) = | |
| 10452 loadVK_VERSION_1_1(instance) | |
| 10453 | |
| 10454 proc loadVK_QCOM_image_processing*(instance: VkInstance) = | |
| 10455 loadVK_VERSION_1_3(instance) | |
| 10456 | |
| 10457 # extension VK_AMD_shader_info | |
| 10458 var | |
| 10459 vkGetShaderInfoAMD*: proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr csize_t, pInfo: pointer): VkResult {.stdcall.} | |
| 10460 proc loadVK_AMD_shader_info*(instance: VkInstance) = | |
| 10461 vkGetShaderInfoAMD = cast[proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr csize_t, pInfo: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetShaderInfoAMD")) | |
| 10462 | |
| 10463 proc loadVK_AMD_gpu_shader_int16*(instance: VkInstance) = | |
| 10464 discard | |
| 10465 | |
| 10466 proc loadVK_EXT_pipeline_robustness*(instance: VkInstance) = | |
| 10467 loadVK_VERSION_1_1(instance) | |
| 10468 | |
| 10469 # extension VK_EXT_sample_locations | |
| 10470 var | |
| 10471 vkCmdSetSampleLocationsEXT*: proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT): void {.stdcall.} | |
| 10472 vkGetPhysicalDeviceMultisamplePropertiesEXT*: proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT): void {.stdcall.} | |
| 10473 proc loadVK_EXT_sample_locations*(instance: VkInstance) = | |
| 10474 loadVK_VERSION_1_1(instance) | |
| 10475 vkCmdSetSampleLocationsEXT = cast[proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEXT")) | |
| 10476 vkGetPhysicalDeviceMultisamplePropertiesEXT = cast[proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) | |
| 10477 | |
| 10478 # extension VK_EXT_descriptor_buffer | |
| 10479 var | |
| 10480 vkGetDescriptorSetLayoutSizeEXT*: proc(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: ptr VkDeviceSize): void {.stdcall.} | |
| 10481 vkGetDescriptorSetLayoutBindingOffsetEXT*: proc(device: VkDevice, layout: VkDescriptorSetLayout, binding: uint32, pOffset: ptr VkDeviceSize): void {.stdcall.} | |
| 10482 vkGetDescriptorEXT*: proc(device: VkDevice, pDescriptorInfo: ptr VkDescriptorGetInfoEXT, dataSize: csize_t, pDescriptor: pointer): void {.stdcall.} | |
| 10483 vkCmdBindDescriptorBuffersEXT*: proc(commandBuffer: VkCommandBuffer, bufferCount: uint32, pBindingInfos: ptr VkDescriptorBufferBindingInfoEXT): void {.stdcall.} | |
| 10484 vkCmdSetDescriptorBufferOffsetsEXT*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, setCount: uint32, pBufferIndices: ptr uint32, pOffsets: ptr VkDeviceSize): void {.stdcall.} | |
| 10485 vkCmdBindDescriptorBufferEmbeddedSamplersEXT*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32): void {.stdcall.} | |
| 10486 vkGetBufferOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkBufferCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.} | |
| 10487 vkGetImageOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkImageCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.} | |
| 10488 vkGetImageViewOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkImageViewCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.} | |
| 10489 vkGetSamplerOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkSamplerCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.} | |
| 10490 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.} | |
| 10491 proc loadVK_EXT_descriptor_buffer*(instance: VkInstance) = | |
| 10492 loadVK_VERSION_1_1(instance) | |
| 10493 loadVK_VERSION_1_2(instance) | |
| 10494 loadVK_VERSION_1_3(instance) | |
| 10495 loadVK_VERSION_1_2(instance) | |
| 10496 vkGetDescriptorSetLayoutSizeEXT = cast[proc(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSizeEXT")) | |
| 10497 vkGetDescriptorSetLayoutBindingOffsetEXT = cast[proc(device: VkDevice, layout: VkDescriptorSetLayout, binding: uint32, pOffset: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutBindingOffsetEXT")) | |
| 10498 vkGetDescriptorEXT = cast[proc(device: VkDevice, pDescriptorInfo: ptr VkDescriptorGetInfoEXT, dataSize: csize_t, pDescriptor: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorEXT")) | |
| 10499 vkCmdBindDescriptorBuffersEXT = cast[proc(commandBuffer: VkCommandBuffer, bufferCount: uint32, pBindingInfos: ptr VkDescriptorBufferBindingInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorBuffersEXT")) | |
| 10500 vkCmdSetDescriptorBufferOffsetsEXT = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, setCount: uint32, pBufferIndices: ptr uint32, pOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDescriptorBufferOffsetsEXT")) | |
| 10501 vkCmdBindDescriptorBufferEmbeddedSamplersEXT = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT")) | |
| 10502 vkGetBufferOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkBufferCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT")) | |
| 10503 vkGetImageOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkImageCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageOpaqueCaptureDescriptorDataEXT")) | |
| 10504 vkGetImageViewOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkImageViewCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT")) | |
| 10505 vkGetSamplerOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkSamplerCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT")) | |
| 10506 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")) | |
| 10507 | |
| 10508 # extension VK_KHR_performance_query | |
| 10509 var | |
| 10510 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32, pCounters: ptr VkPerformanceCounterKHR, pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR): VkResult {.stdcall.} | |
| 10511 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR*: proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: ptr uint32): void {.stdcall.} | |
| 10512 vkAcquireProfilingLockKHR*: proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR): VkResult {.stdcall.} | |
| 10513 vkReleaseProfilingLockKHR*: proc(device: VkDevice): void {.stdcall.} | |
| 10514 proc loadVK_KHR_performance_query*(instance: VkInstance) = | |
| 10515 loadVK_VERSION_1_1(instance) | |
| 10516 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32, pCounters: ptr VkPerformanceCounterKHR, pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")) | |
| 10517 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: ptr uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")) | |
| 10518 vkAcquireProfilingLockKHR = cast[proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR")) | |
| 10519 vkReleaseProfilingLockKHR = cast[proc(device: VkDevice): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR")) | |
| 10520 | |
| 10521 proc loadVK_GOOGLE_user_type*(instance: VkInstance) = | |
| 10522 discard | |
| 10523 | |
| 10524 # extension VK_EXT_debug_report | |
| 10525 var | |
| 10526 vkCreateDebugReportCallbackEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pCallback: ptr VkDebugReportCallbackEXT): VkResult {.stdcall.} | |
| 10527 vkDestroyDebugReportCallbackEXT*: proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10528 vkDebugReportMessageEXT*: proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, theobject: uint64, location: csize_t, messageCode: int32, pLayerPrefix: cstring, pMessage: cstring): void {.stdcall.} | |
| 10529 proc loadVK_EXT_debug_report*(instance: VkInstance) = | |
| 10530 vkCreateDebugReportCallbackEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pCallback: ptr VkDebugReportCallbackEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT")) | |
| 10531 vkDestroyDebugReportCallbackEXT = cast[proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT")) | |
| 10532 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")) | |
| 10533 | |
| 10534 proc loadVK_EXT_multisampled_render_to_single_sampled*(instance: VkInstance) = | |
| 10535 loadVK_VERSION_1_2(instance) | |
| 10536 loadVK_VERSION_1_2(instance) | |
| 10537 | |
| 10538 proc loadVK_AMD_negative_viewport_height*(instance: VkInstance) = | |
| 10539 discard | |
| 10540 | |
| 10541 proc loadVK_EXT_provoking_vertex*(instance: VkInstance) = | |
| 10542 loadVK_VERSION_1_1(instance) | |
| 10543 | |
| 10544 proc loadVK_NV_device_diagnostics_config*(instance: VkInstance) = | |
| 10545 loadVK_VERSION_1_1(instance) | |
| 10546 | |
| 10547 proc loadVK_NV_shader_subgroup_partitioned*(instance: VkInstance) = | |
| 10548 loadVK_VERSION_1_1(instance) | |
| 10549 | |
| 10550 proc loadVK_EXT_image_sliced_view_of_3d*(instance: VkInstance) = | |
| 10551 loadVK_VERSION_1_1(instance) | |
| 10552 loadVK_VERSION_1_1(instance) | |
| 10553 | |
| 10554 proc loadVK_AMD_shader_image_load_store_lod*(instance: VkInstance) = | |
| 10555 discard | |
| 10556 | |
| 10557 proc loadVK_INTEL_shader_integer_functions2*(instance: VkInstance) = | |
| 10558 loadVK_VERSION_1_1(instance) | |
| 10559 | |
| 10560 proc loadVK_EXT_image_2d_view_of_3d*(instance: VkInstance) = | |
| 10561 loadVK_VERSION_1_1(instance) | |
| 10562 loadVK_VERSION_1_1(instance) | |
| 10563 | |
| 10564 # extension VK_NV_shading_rate_image | |
| 10565 var | |
| 10566 vkCmdBindShadingRateImageNV*: proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.} | |
| 10567 vkCmdSetViewportShadingRatePaletteNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV): void {.stdcall.} | |
| 10568 vkCmdSetCoarseSampleOrderNV*: proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV): void {.stdcall.} | |
| 10569 proc loadVK_NV_shading_rate_image*(instance: VkInstance) = | |
| 10570 loadVK_VERSION_1_1(instance) | |
| 10571 vkCmdBindShadingRateImageNV = cast[proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindShadingRateImageNV")) | |
| 10572 vkCmdSetViewportShadingRatePaletteNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportShadingRatePaletteNV")) | |
| 10573 vkCmdSetCoarseSampleOrderNV = cast[proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoarseSampleOrderNV")) | |
| 10574 | |
| 10575 proc loadVK_EXT_fragment_density_map*(instance: VkInstance) = | |
| 10576 loadVK_VERSION_1_1(instance) | |
| 10577 | |
| 10578 # extension VK_NV_device_diagnostic_checkpoints | |
| 10579 var | |
| 10580 vkCmdSetCheckpointNV*: proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer): void {.stdcall.} | |
| 10581 vkGetQueueCheckpointDataNV*: proc(queue: VkQueue, pCheckpointDataCount: ptr uint32, pCheckpointData: ptr VkCheckpointDataNV): void {.stdcall.} | |
| 10582 proc loadVK_NV_device_diagnostic_checkpoints*(instance: VkInstance) = | |
| 10583 loadVK_VERSION_1_1(instance) | |
| 10584 vkCmdSetCheckpointNV = cast[proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCheckpointNV")) | |
| 10585 vkGetQueueCheckpointDataNV = cast[proc(queue: VkQueue, pCheckpointDataCount: ptr uint32, pCheckpointData: ptr VkCheckpointDataNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetQueueCheckpointDataNV")) | |
| 10586 | |
| 10587 proc loadVK_EXT_pci_bus_info*(instance: VkInstance) = | |
| 10588 loadVK_VERSION_1_1(instance) | |
| 10589 | |
| 10590 proc loadVK_EXT_queue_family_foreign*(instance: VkInstance) = | |
| 10591 loadVK_VERSION_1_1(instance) | |
| 10592 | |
| 10593 # extension VK_EXT_debug_utils | |
| 10594 var | |
| 10595 vkSetDebugUtilsObjectNameEXT*: proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT): VkResult {.stdcall.} | |
| 10596 vkSetDebugUtilsObjectTagEXT*: proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT): VkResult {.stdcall.} | |
| 10597 vkQueueBeginDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.} | |
| 10598 vkQueueEndDebugUtilsLabelEXT*: proc(queue: VkQueue): void {.stdcall.} | |
| 10599 vkQueueInsertDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.} | |
| 10600 vkCmdBeginDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.} | |
| 10601 vkCmdEndDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.} | |
| 10602 vkCmdInsertDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.} | |
| 10603 vkCreateDebugUtilsMessengerEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMessenger: ptr VkDebugUtilsMessengerEXT): VkResult {.stdcall.} | |
| 10604 vkDestroyDebugUtilsMessengerEXT*: proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10605 vkSubmitDebugUtilsMessageEXT*: proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT): void {.stdcall.} | |
| 10606 proc loadVK_EXT_debug_utils*(instance: VkInstance) = | |
| 10607 vkSetDebugUtilsObjectNameEXT = cast[proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT")) | |
| 10608 vkSetDebugUtilsObjectTagEXT = cast[proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT")) | |
| 10609 vkQueueBeginDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT")) | |
| 10610 vkQueueEndDebugUtilsLabelEXT = cast[proc(queue: VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT")) | |
| 10611 vkQueueInsertDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT")) | |
| 10612 vkCmdBeginDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT")) | |
| 10613 vkCmdEndDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT")) | |
| 10614 vkCmdInsertDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT")) | |
| 10615 vkCreateDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMessenger: ptr VkDebugUtilsMessengerEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT")) | |
| 10616 vkDestroyDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT")) | |
| 10617 vkSubmitDebugUtilsMessageEXT = cast[proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT")) | |
| 10618 | |
| 10619 proc loadVK_KHR_portability_enumeration*(instance: VkInstance) = | |
| 10620 discard | |
| 10621 | |
| 10622 proc loadVK_EXT_memory_priority*(instance: VkInstance) = | |
| 10623 loadVK_VERSION_1_1(instance) | |
| 10624 | |
| 10625 proc loadVK_AMD_shader_core_properties*(instance: VkInstance) = | |
| 10626 loadVK_VERSION_1_1(instance) | |
| 10627 | |
| 10628 # extension VK_KHR_external_fence_fd | |
| 10629 var | |
| 10630 vkImportFenceFdKHR*: proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR): VkResult {.stdcall.} | |
| 10631 vkGetFenceFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.} | |
| 10632 proc loadVK_KHR_external_fence_fd*(instance: VkInstance) = | |
| 10633 loadVK_VERSION_1_1(instance) | |
| 10634 vkImportFenceFdKHR = cast[proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkImportFenceFdKHR")) | |
| 10635 vkGetFenceFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetFenceFdKHR")) | |
| 10636 | |
| 10637 # extension VK_NV_device_generated_commands | |
| 10638 var | |
| 10639 vkGetGeneratedCommandsMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.} | |
| 10640 vkCmdPreprocessGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.} | |
| 10641 vkCmdExecuteGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.} | |
| 10642 vkCmdBindPipelineShaderGroupNV*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.} | |
| 10643 vkCreateIndirectCommandsLayoutNV*: proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV): VkResult {.stdcall.} | |
| 10644 vkDestroyIndirectCommandsLayoutNV*: proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10645 proc loadVK_NV_device_generated_commands*(instance: VkInstance) = | |
| 10646 loadVK_VERSION_1_1(instance) | |
| 10647 loadVK_VERSION_1_2(instance) | |
| 10648 vkGetGeneratedCommandsMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetGeneratedCommandsMemoryRequirementsNV")) | |
| 10649 vkCmdPreprocessGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPreprocessGeneratedCommandsNV")) | |
| 10650 vkCmdExecuteGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdExecuteGeneratedCommandsNV")) | |
| 10651 vkCmdBindPipelineShaderGroupNV = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindPipelineShaderGroupNV")) | |
| 10652 vkCreateIndirectCommandsLayoutNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateIndirectCommandsLayoutNV")) | |
| 10653 vkDestroyIndirectCommandsLayoutNV = cast[proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyIndirectCommandsLayoutNV")) | |
| 10654 | |
| 10655 proc loadVK_NV_viewport_array2*(instance: VkInstance) = | |
| 10656 discard | |
| 10657 | |
| 10658 proc loadVK_NVX_multiview_per_view_attributes*(instance: VkInstance) = | |
| 10659 loadVK_VERSION_1_1(instance) | |
| 10660 | |
| 10661 # extension VK_KHR_external_memory_fd | |
| 10662 var | |
| 10663 vkGetMemoryFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.} | |
| 10664 vkGetMemoryFdPropertiesKHR*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: cint, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR): VkResult {.stdcall.} | |
| 10665 proc loadVK_KHR_external_memory_fd*(instance: VkInstance) = | |
| 10666 loadVK_VERSION_1_1(instance) | |
| 10667 vkGetMemoryFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryFdKHR")) | |
| 10668 vkGetMemoryFdPropertiesKHR = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: cint, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR")) | |
| 10669 | |
| 10670 proc loadVK_EXT_rgba10x6_formats*(instance: VkInstance) = | |
| 10671 loadVK_VERSION_1_1(instance) | |
| 10672 | |
| 10673 proc loadVK_NV_dedicated_allocation_image_aliasing*(instance: VkInstance) = | |
| 10674 loadVK_VERSION_1_1(instance) | |
| 10675 loadVK_VERSION_1_1(instance) | |
| 10676 | |
| 10677 # extension VK_NV_cooperative_matrix | |
| 10678 var | |
| 10679 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkCooperativeMatrixPropertiesNV): VkResult {.stdcall.} | |
| 10680 proc loadVK_NV_cooperative_matrix*(instance: VkInstance) = | |
| 10681 loadVK_VERSION_1_1(instance) | |
| 10682 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkCooperativeMatrixPropertiesNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")) | |
| 10683 | |
| 10684 proc loadVK_EXT_depth_clamp_zero_one*(instance: VkInstance) = | |
| 10685 loadVK_VERSION_1_1(instance) | |
| 10686 | |
| 10687 proc loadVK_NV_linear_color_attachment*(instance: VkInstance) = | |
| 10688 loadVK_VERSION_1_1(instance) | |
| 10689 | |
| 10690 proc loadVK_EXT_shader_subgroup_ballot*(instance: VkInstance) = | |
| 10691 discard | |
| 10692 | |
| 10693 # extension VK_EXT_image_drm_format_modifier | |
| 10694 var | |
| 10695 vkGetImageDrmFormatModifierPropertiesEXT*: proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT): VkResult {.stdcall.} | |
| 10696 proc loadVK_EXT_image_drm_format_modifier*(instance: VkInstance) = | |
| 10697 loadVK_VERSION_1_1(instance) | |
| 10698 loadVK_VERSION_1_1(instance) | |
| 10699 loadVK_VERSION_1_2(instance) | |
| 10700 loadVK_VERSION_1_1(instance) | |
| 10701 vkGetImageDrmFormatModifierPropertiesEXT = cast[proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageDrmFormatModifierPropertiesEXT")) | |
| 10702 | |
| 10703 # extension VK_EXT_mesh_shader | |
| 10704 var | |
| 10705 vkCmdDrawMeshTasksEXT*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.} | |
| 10706 vkCmdDrawMeshTasksIndirectEXT*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10707 vkCmdDrawMeshTasksIndirectCountEXT*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10708 proc loadVK_EXT_mesh_shader*(instance: VkInstance) = | |
| 10709 loadVK_VERSION_1_2(instance) | |
| 10710 vkCmdDrawMeshTasksEXT = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksEXT")) | |
| 10711 vkCmdDrawMeshTasksIndirectEXT = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectEXT")) | |
| 10712 vkCmdDrawMeshTasksIndirectCountEXT = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountEXT")) | |
| 10713 | |
| 10714 # extension VK_EXT_transform_feedback | |
| 10715 var | |
| 10716 vkCmdBindTransformFeedbackBuffersEXT*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize): void {.stdcall.} | |
| 10717 vkCmdBeginTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.} | |
| 10718 vkCmdEndTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.} | |
| 10719 vkCmdBeginQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.} | |
| 10720 vkCmdEndQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.} | |
| 10721 vkCmdDrawIndirectByteCountEXT*: proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.} | |
| 10722 proc loadVK_EXT_transform_feedback*(instance: VkInstance) = | |
| 10723 loadVK_VERSION_1_1(instance) | |
| 10724 vkCmdBindTransformFeedbackBuffersEXT = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer, pOffsets: ptr VkDeviceSize, pSizes: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindTransformFeedbackBuffersEXT")) | |
| 10725 vkCmdBeginTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginTransformFeedbackEXT")) | |
| 10726 vkCmdEndTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer, pCounterBufferOffsets: ptr VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndTransformFeedbackEXT")) | |
| 10727 vkCmdBeginQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT")) | |
| 10728 vkCmdEndQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT")) | |
| 10729 vkCmdDrawIndirectByteCountEXT = cast[proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT")) | |
| 10730 | |
| 10731 proc loadVK_AMD_shader_early_and_late_fragment_tests*(instance: VkInstance) = | |
| 10732 loadVK_VERSION_1_1(instance) | |
| 10733 | |
| 10734 proc loadVK_AMD_shader_core_properties2*(instance: VkInstance) = | |
| 10735 loadVK_AMD_shader_core_properties(instance) | |
| 10736 | |
| 10737 proc loadVK_GOOGLE_hlsl_functionality1*(instance: VkInstance) = | |
| 10738 discard | |
| 10739 | |
| 10740 proc loadVK_EXT_robustness2*(instance: VkInstance) = | |
| 10741 loadVK_VERSION_1_1(instance) | |
| 10742 | |
| 10743 proc loadVK_EXT_image_view_min_lod*(instance: VkInstance) = | |
| 10744 loadVK_VERSION_1_1(instance) | |
| 10745 | |
| 10746 proc loadVK_AMD_shader_trinary_minmax*(instance: VkInstance) = | |
| 10747 discard | |
| 10748 | |
| 10749 proc loadVK_EXT_custom_border_color*(instance: VkInstance) = | |
| 10750 loadVK_VERSION_1_1(instance) | |
| 10751 | |
| 10752 proc loadVK_AMD_rasterization_order*(instance: VkInstance) = | |
| 10753 discard | |
| 10754 | |
| 10755 # extension VK_EXT_vertex_input_dynamic_state | |
| 10756 var | |
| 10757 vkCmdSetVertexInputEXT*: proc(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32, pVertexBindingDescriptions: ptr VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32, pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription2EXT): void {.stdcall.} | |
| 10758 proc loadVK_EXT_vertex_input_dynamic_state*(instance: VkInstance) = | |
| 10759 loadVK_VERSION_1_1(instance) | |
| 10760 vkCmdSetVertexInputEXT = cast[proc(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32, pVertexBindingDescriptions: ptr VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32, pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription2EXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetVertexInputEXT")) | |
| 10761 | |
| 10762 # extension VK_KHR_fragment_shading_rate | |
| 10763 var | |
| 10764 vkGetPhysicalDeviceFragmentShadingRatesKHR*: proc(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: ptr uint32, pFragmentShadingRates: ptr VkPhysicalDeviceFragmentShadingRateKHR): VkResult {.stdcall.} | |
| 10765 vkCmdSetFragmentShadingRateKHR*: proc(commandBuffer: VkCommandBuffer, pFragmentSize: ptr VkExtent2D, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.} | |
| 10766 proc loadVK_KHR_fragment_shading_rate*(instance: VkInstance) = | |
| 10767 loadVK_VERSION_1_2(instance) | |
| 10768 loadVK_VERSION_1_1(instance) | |
| 10769 vkGetPhysicalDeviceFragmentShadingRatesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: ptr uint32, pFragmentShadingRates: ptr VkPhysicalDeviceFragmentShadingRateKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")) | |
| 10770 vkCmdSetFragmentShadingRateKHR = cast[proc(commandBuffer: VkCommandBuffer, pFragmentSize: ptr VkExtent2D, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateKHR")) | |
| 10771 | |
| 10772 proc loadVK_EXT_depth_clip_enable*(instance: VkInstance) = | |
| 10773 loadVK_VERSION_1_1(instance) | |
| 10774 | |
| 10775 proc loadVK_EXT_subpass_merge_feedback*(instance: VkInstance) = | |
| 10776 loadVK_VERSION_1_1(instance) | |
| 10777 | |
| 10778 # extension VK_KHR_external_semaphore_fd | |
| 10779 var | |
| 10780 vkImportSemaphoreFdKHR*: proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR): VkResult {.stdcall.} | |
| 10781 vkGetSemaphoreFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.} | |
| 10782 proc loadVK_KHR_external_semaphore_fd*(instance: VkInstance) = | |
| 10783 loadVK_VERSION_1_1(instance) | |
| 10784 vkImportSemaphoreFdKHR = cast[proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkImportSemaphoreFdKHR")) | |
| 10785 vkGetSemaphoreFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR, pFd: ptr cint): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSemaphoreFdKHR")) | |
| 10786 | |
| 10787 proc loadVK_KHR_fragment_shader_barycentric*(instance: VkInstance) = | |
| 10788 loadVK_VERSION_1_1(instance) | |
| 10789 | |
| 10790 proc loadVK_EXT_memory_budget*(instance: VkInstance) = | |
| 10791 loadVK_VERSION_1_1(instance) | |
| 10792 | |
| 10793 proc loadVK_AMD_device_coherent_memory*(instance: VkInstance) = | |
| 10794 loadVK_VERSION_1_1(instance) | |
| 10795 | |
| 10796 proc loadVK_EXT_device_memory_report*(instance: VkInstance) = | |
| 10797 loadVK_VERSION_1_1(instance) | |
| 10798 | |
| 10799 proc loadVK_AMD_memory_overallocation_behavior*(instance: VkInstance) = | |
| 10800 discard | |
| 10801 | |
| 10802 # extension VK_NV_mesh_shader | |
| 10803 var | |
| 10804 vkCmdDrawMeshTasksNV*: proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.} | |
| 10805 vkCmdDrawMeshTasksIndirectNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10806 vkCmdDrawMeshTasksIndirectCountNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.} | |
| 10807 proc loadVK_NV_mesh_shader*(instance: VkInstance) = | |
| 10808 loadVK_VERSION_1_1(instance) | |
| 10809 vkCmdDrawMeshTasksNV = cast[proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksNV")) | |
| 10810 vkCmdDrawMeshTasksIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectNV")) | |
| 10811 vkCmdDrawMeshTasksIndirectCountNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV")) | |
| 10812 | |
| 10813 # extension VK_EXT_image_compression_control | |
| 10814 var | |
| 10815 vkGetImageSubresourceLayout2EXT*: proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource2EXT, pLayout: ptr VkSubresourceLayout2EXT): void {.stdcall.} | |
| 10816 proc loadVK_EXT_image_compression_control*(instance: VkInstance) = | |
| 10817 loadVK_VERSION_1_1(instance) | |
| 10818 vkGetImageSubresourceLayout2EXT = cast[proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource2EXT, pLayout: ptr VkSubresourceLayout2EXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout2EXT")) | |
| 10819 | |
| 10820 # extension VK_EXT_buffer_device_address | |
| 10821 var | |
| 10822 vkGetBufferDeviceAddressEXT*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo): VkDeviceAddress {.stdcall.} | |
| 10823 proc loadVK_EXT_buffer_device_address*(instance: VkInstance) = | |
| 10824 loadVK_VERSION_1_1(instance) | |
| 10825 vkGetBufferDeviceAddressEXT = vkGetBufferDeviceAddress | |
| 10826 | |
| 10827 proc loadVK_QCOM_render_pass_shader_resolve*(instance: VkInstance) = | |
| 10828 discard | |
| 10829 | |
| 10830 proc loadVK_EXT_depth_range_unrestricted*(instance: VkInstance) = | |
| 10831 discard | |
| 10832 | |
| 10833 # extension VK_HUAWEI_subpass_shading | |
| 10834 var | |
| 10835 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI*: proc(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: ptr VkExtent2D): VkResult {.stdcall.} | |
| 10836 vkCmdSubpassShadingHUAWEI*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.} | |
| 10837 proc loadVK_HUAWEI_subpass_shading*(instance: VkInstance) = | |
| 10838 loadVK_VERSION_1_2(instance) | |
| 10839 loadVK_VERSION_1_3(instance) | |
| 10840 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = cast[proc(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: ptr VkExtent2D): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")) | |
| 10841 vkCmdSubpassShadingHUAWEI = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSubpassShadingHUAWEI")) | |
| 10842 | |
| 10843 # extension VK_VALVE_descriptor_set_host_mapping | |
| 10844 var | |
| 10845 vkGetDescriptorSetLayoutHostMappingInfoVALVE*: proc(device: VkDevice, pBindingReference: ptr VkDescriptorSetBindingReferenceVALVE, pHostMapping: ptr VkDescriptorSetLayoutHostMappingInfoVALVE): void {.stdcall.} | |
| 10846 vkGetDescriptorSetHostMappingVALVE*: proc(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: ptr pointer): void {.stdcall.} | |
| 10847 proc loadVK_VALVE_descriptor_set_host_mapping*(instance: VkInstance) = | |
| 10848 loadVK_VERSION_1_1(instance) | |
| 10849 vkGetDescriptorSetLayoutHostMappingInfoVALVE = cast[proc(device: VkDevice, pBindingReference: ptr VkDescriptorSetBindingReferenceVALVE, pHostMapping: ptr VkDescriptorSetLayoutHostMappingInfoVALVE): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE")) | |
| 10850 vkGetDescriptorSetHostMappingVALVE = cast[proc(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: ptr pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDescriptorSetHostMappingVALVE")) | |
| 10851 | |
| 10852 # extension VK_NV_external_memory_capabilities | |
| 10853 var | |
| 10854 vkGetPhysicalDeviceExternalImageFormatPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, thetype: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV): VkResult {.stdcall.} | |
| 10855 proc loadVK_NV_external_memory_capabilities*(instance: VkInstance) = | |
| 10856 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")) | |
| 10857 | |
| 10858 # extension VK_NV_optical_flow | |
| 10859 var | |
| 10860 vkGetPhysicalDeviceOpticalFlowImageFormatsNV*: proc(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: ptr VkOpticalFlowImageFormatInfoNV, pFormatCount: ptr uint32, pImageFormatProperties: ptr VkOpticalFlowImageFormatPropertiesNV): VkResult {.stdcall.} | |
| 10861 vkCreateOpticalFlowSessionNV*: proc(device: VkDevice, pCreateInfo: ptr VkOpticalFlowSessionCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pSession: ptr VkOpticalFlowSessionNV): VkResult {.stdcall.} | |
| 10862 vkDestroyOpticalFlowSessionNV*: proc(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 10863 vkBindOpticalFlowSessionImageNV*: proc(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout): VkResult {.stdcall.} | |
| 10864 vkCmdOpticalFlowExecuteNV*: proc(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: ptr VkOpticalFlowExecuteInfoNV): void {.stdcall.} | |
| 10865 proc loadVK_NV_optical_flow*(instance: VkInstance) = | |
| 10866 loadVK_VERSION_1_1(instance) | |
| 10867 loadVK_VERSION_1_3(instance) | |
| 10868 loadVK_VERSION_1_3(instance) | |
| 10869 vkGetPhysicalDeviceOpticalFlowImageFormatsNV = cast[proc(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: ptr VkOpticalFlowImageFormatInfoNV, pFormatCount: ptr uint32, pImageFormatProperties: ptr VkOpticalFlowImageFormatPropertiesNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV")) | |
| 10870 vkCreateOpticalFlowSessionNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkOpticalFlowSessionCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pSession: ptr VkOpticalFlowSessionNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateOpticalFlowSessionNV")) | |
| 10871 vkDestroyOpticalFlowSessionNV = cast[proc(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyOpticalFlowSessionNV")) | |
| 10872 vkBindOpticalFlowSessionImageNV = cast[proc(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindOpticalFlowSessionImageNV")) | |
| 10873 vkCmdOpticalFlowExecuteNV = cast[proc(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: ptr VkOpticalFlowExecuteInfoNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdOpticalFlowExecuteNV")) | |
| 10874 | |
| 10875 proc loadVK_EXT_vertex_attribute_divisor*(instance: VkInstance) = | |
| 10876 loadVK_VERSION_1_1(instance) | |
| 10877 | |
| 10878 # extension VK_EXT_line_rasterization | |
| 10879 var | |
| 10880 vkCmdSetLineStippleEXT*: proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.} | |
| 10881 proc loadVK_EXT_line_rasterization*(instance: VkInstance) = | |
| 10882 loadVK_VERSION_1_1(instance) | |
| 10883 vkCmdSetLineStippleEXT = cast[proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineStippleEXT")) | |
| 10884 | |
| 10885 proc loadVK_AMD_texture_gather_bias_lod*(instance: VkInstance) = | |
| 10886 loadVK_VERSION_1_1(instance) | |
| 10887 | |
| 10888 proc loadVK_KHR_shader_subgroup_uniform_control_flow*(instance: VkInstance) = | |
| 10889 loadVK_VERSION_1_1(instance) | |
| 10890 | |
| 10891 proc loadVK_EXT_external_memory_dma_buf*(instance: VkInstance) = | |
| 10892 loadVK_KHR_external_memory_fd(instance) | |
| 10893 | |
| 10894 proc loadVK_IMG_filter_cubic*(instance: VkInstance) = | |
| 10895 discard | |
| 10896 | |
| 10897 proc loadVK_AMD_shader_ballot*(instance: VkInstance) = | |
| 10898 discard | |
| 10899 | |
| 10900 # extension VK_AMD_buffer_marker | |
| 10901 var | |
| 10902 vkCmdWriteBufferMarkerAMD*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.} | |
| 10903 proc loadVK_AMD_buffer_marker*(instance: VkInstance) = | |
| 10904 vkCmdWriteBufferMarkerAMD = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteBufferMarkerAMD")) | |
| 10905 | |
| 10906 proc loadVK_NV_corner_sampled_image*(instance: VkInstance) = | |
| 10907 loadVK_VERSION_1_1(instance) | |
| 10908 | |
| 10909 proc loadVK_KHR_pipeline_library*(instance: VkInstance) = | |
| 10910 discard | |
| 10911 | |
| 10912 proc loadVK_EXT_blend_operation_advanced*(instance: VkInstance) = | |
| 10913 loadVK_VERSION_1_1(instance) | |
| 10914 | |
| 10915 # extension VK_NV_scissor_exclusive | |
| 10916 var | |
| 10917 vkCmdSetExclusiveScissorEnableNV*: proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissorEnables: ptr VkBool32): void {.stdcall.} | |
| 10918 vkCmdSetExclusiveScissorNV*: proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D): void {.stdcall.} | |
| 10919 proc loadVK_NV_scissor_exclusive*(instance: VkInstance) = | |
| 10920 loadVK_VERSION_1_1(instance) | |
| 10921 vkCmdSetExclusiveScissorEnableNV = cast[proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissorEnables: ptr VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorEnableNV")) | |
| 10922 vkCmdSetExclusiveScissorNV = cast[proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorNV")) | |
| 10923 | |
| 10924 proc loadVK_NV_framebuffer_mixed_samples*(instance: VkInstance) = | |
| 10925 discard | |
| 10926 | |
| 10927 proc loadVK_NV_sample_mask_override_coverage*(instance: VkInstance) = | |
| 10928 discard | |
| 10929 | |
| 10930 proc loadVK_EXT_filter_cubic*(instance: VkInstance) = | |
| 10931 discard | |
| 10932 | |
| 10933 # extension VK_KHR_pipeline_executable_properties | |
| 10934 var | |
| 10935 vkGetPipelineExecutablePropertiesKHR*: proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR, pExecutableCount: ptr uint32, pProperties: ptr VkPipelineExecutablePropertiesKHR): VkResult {.stdcall.} | |
| 10936 vkGetPipelineExecutableStatisticsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pStatisticCount: ptr uint32, pStatistics: ptr VkPipelineExecutableStatisticKHR): VkResult {.stdcall.} | |
| 10937 vkGetPipelineExecutableInternalRepresentationsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pInternalRepresentationCount: ptr uint32, pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR): VkResult {.stdcall.} | |
| 10938 proc loadVK_KHR_pipeline_executable_properties*(instance: VkInstance) = | |
| 10939 loadVK_VERSION_1_1(instance) | |
| 10940 vkGetPipelineExecutablePropertiesKHR = cast[proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR, pExecutableCount: ptr uint32, pProperties: ptr VkPipelineExecutablePropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineExecutablePropertiesKHR")) | |
| 10941 vkGetPipelineExecutableStatisticsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pStatisticCount: ptr uint32, pStatistics: ptr VkPipelineExecutableStatisticKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableStatisticsKHR")) | |
| 10942 vkGetPipelineExecutableInternalRepresentationsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR, pInternalRepresentationCount: ptr uint32, pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableInternalRepresentationsKHR")) | |
| 10943 | |
| 10944 # extension VK_EXT_extended_dynamic_state3 | |
| 10945 var | |
| 10946 vkCmdSetTessellationDomainOriginEXT*: proc(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin): void {.stdcall.} | |
| 10947 vkCmdSetDepthClampEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32): void {.stdcall.} | |
| 10948 vkCmdSetPolygonModeEXT*: proc(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode): void {.stdcall.} | |
| 10949 vkCmdSetRasterizationSamplesEXT*: proc(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits): void {.stdcall.} | |
| 10950 vkCmdSetSampleMaskEXT*: proc(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: ptr VkSampleMask): void {.stdcall.} | |
| 10951 vkCmdSetAlphaToCoverageEnableEXT*: proc(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32): void {.stdcall.} | |
| 10952 vkCmdSetAlphaToOneEnableEXT*: proc(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32): void {.stdcall.} | |
| 10953 vkCmdSetLogicOpEnableEXT*: proc(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32): void {.stdcall.} | |
| 10954 vkCmdSetColorBlendEnableEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEnables: ptr VkBool32): void {.stdcall.} | |
| 10955 vkCmdSetColorBlendEquationEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEquations: ptr VkColorBlendEquationEXT): void {.stdcall.} | |
| 10956 vkCmdSetColorWriteMaskEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorWriteMasks: ptr VkColorComponentFlags): void {.stdcall.} | |
| 10957 vkCmdSetRasterizationStreamEXT*: proc(commandBuffer: VkCommandBuffer, rasterizationStream: uint32): void {.stdcall.} | |
| 10958 vkCmdSetConservativeRasterizationModeEXT*: proc(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT): void {.stdcall.} | |
| 10959 vkCmdSetExtraPrimitiveOverestimationSizeEXT*: proc(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float32): void {.stdcall.} | |
| 10960 vkCmdSetDepthClipEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32): void {.stdcall.} | |
| 10961 vkCmdSetSampleLocationsEnableEXT*: proc(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32): void {.stdcall.} | |
| 10962 vkCmdSetColorBlendAdvancedEXT*: proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendAdvanced: ptr VkColorBlendAdvancedEXT): void {.stdcall.} | |
| 10963 vkCmdSetProvokingVertexModeEXT*: proc(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT): void {.stdcall.} | |
| 10964 vkCmdSetLineRasterizationModeEXT*: proc(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT): void {.stdcall.} | |
| 10965 vkCmdSetLineStippleEnableEXT*: proc(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32): void {.stdcall.} | |
| 10966 vkCmdSetDepthClipNegativeOneToOneEXT*: proc(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32): void {.stdcall.} | |
| 10967 vkCmdSetViewportWScalingEnableNV*: proc(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32): void {.stdcall.} | |
| 10968 vkCmdSetViewportSwizzleNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportSwizzles: ptr VkViewportSwizzleNV): void {.stdcall.} | |
| 10969 vkCmdSetCoverageToColorEnableNV*: proc(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32): void {.stdcall.} | |
| 10970 vkCmdSetCoverageToColorLocationNV*: proc(commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32): void {.stdcall.} | |
| 10971 vkCmdSetCoverageModulationModeNV*: proc(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV): void {.stdcall.} | |
| 10972 vkCmdSetCoverageModulationTableEnableNV*: proc(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32): void {.stdcall.} | |
| 10973 vkCmdSetCoverageModulationTableNV*: proc(commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32, pCoverageModulationTable: ptr float32): void {.stdcall.} | |
| 10974 vkCmdSetShadingRateImageEnableNV*: proc(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32): void {.stdcall.} | |
| 10975 vkCmdSetRepresentativeFragmentTestEnableNV*: proc(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32): void {.stdcall.} | |
| 10976 vkCmdSetCoverageReductionModeNV*: proc(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV): void {.stdcall.} | |
| 10977 proc loadVK_EXT_extended_dynamic_state3*(instance: VkInstance) = | |
| 10978 loadVK_VERSION_1_1(instance) | |
| 10979 vkCmdSetTessellationDomainOriginEXT = cast[proc(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetTessellationDomainOriginEXT")) | |
| 10980 vkCmdSetDepthClampEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthClampEnableEXT")) | |
| 10981 vkCmdSetPolygonModeEXT = cast[proc(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPolygonModeEXT")) | |
| 10982 vkCmdSetRasterizationSamplesEXT = cast[proc(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRasterizationSamplesEXT")) | |
| 10983 vkCmdSetSampleMaskEXT = cast[proc(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: ptr VkSampleMask): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetSampleMaskEXT")) | |
| 10984 vkCmdSetAlphaToCoverageEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetAlphaToCoverageEnableEXT")) | |
| 10985 vkCmdSetAlphaToOneEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetAlphaToOneEnableEXT")) | |
| 10986 vkCmdSetLogicOpEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLogicOpEnableEXT")) | |
| 10987 vkCmdSetColorBlendEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEnables: ptr VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorBlendEnableEXT")) | |
| 10988 vkCmdSetColorBlendEquationEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendEquations: ptr VkColorBlendEquationEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorBlendEquationEXT")) | |
| 10989 vkCmdSetColorWriteMaskEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorWriteMasks: ptr VkColorComponentFlags): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorWriteMaskEXT")) | |
| 10990 vkCmdSetRasterizationStreamEXT = cast[proc(commandBuffer: VkCommandBuffer, rasterizationStream: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRasterizationStreamEXT")) | |
| 10991 vkCmdSetConservativeRasterizationModeEXT = cast[proc(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetConservativeRasterizationModeEXT")) | |
| 10992 vkCmdSetExtraPrimitiveOverestimationSizeEXT = cast[proc(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT")) | |
| 10993 vkCmdSetDepthClipEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthClipEnableEXT")) | |
| 10994 vkCmdSetSampleLocationsEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEnableEXT")) | |
| 10995 vkCmdSetColorBlendAdvancedEXT = cast[proc(commandBuffer: VkCommandBuffer, firstAttachment: uint32, attachmentCount: uint32, pColorBlendAdvanced: ptr VkColorBlendAdvancedEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorBlendAdvancedEXT")) | |
| 10996 vkCmdSetProvokingVertexModeEXT = cast[proc(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetProvokingVertexModeEXT")) | |
| 10997 vkCmdSetLineRasterizationModeEXT = cast[proc(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineRasterizationModeEXT")) | |
| 10998 vkCmdSetLineStippleEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetLineStippleEnableEXT")) | |
| 10999 vkCmdSetDepthClipNegativeOneToOneEXT = cast[proc(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDepthClipNegativeOneToOneEXT")) | |
| 11000 vkCmdSetViewportWScalingEnableNV = cast[proc(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportWScalingEnableNV")) | |
| 11001 vkCmdSetViewportSwizzleNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportSwizzles: ptr VkViewportSwizzleNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportSwizzleNV")) | |
| 11002 vkCmdSetCoverageToColorEnableNV = cast[proc(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageToColorEnableNV")) | |
| 11003 vkCmdSetCoverageToColorLocationNV = cast[proc(commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageToColorLocationNV")) | |
| 11004 vkCmdSetCoverageModulationModeNV = cast[proc(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageModulationModeNV")) | |
| 11005 vkCmdSetCoverageModulationTableEnableNV = cast[proc(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageModulationTableEnableNV")) | |
| 11006 vkCmdSetCoverageModulationTableNV = cast[proc(commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32, pCoverageModulationTable: ptr float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageModulationTableNV")) | |
| 11007 vkCmdSetShadingRateImageEnableNV = cast[proc(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetShadingRateImageEnableNV")) | |
| 11008 vkCmdSetRepresentativeFragmentTestEnableNV = cast[proc(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRepresentativeFragmentTestEnableNV")) | |
| 11009 vkCmdSetCoverageReductionModeNV = cast[proc(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetCoverageReductionModeNV")) | |
| 11010 | |
| 11011 proc loadVK_EXT_device_address_binding_report*(instance: VkInstance) = | |
| 11012 loadVK_VERSION_1_1(instance) | |
| 11013 loadVK_EXT_debug_utils(instance) | |
| 11014 | |
| 11015 # extension VK_NV_clip_space_w_scaling | |
| 11016 var | |
| 11017 vkCmdSetViewportWScalingNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV): void {.stdcall.} | |
| 11018 proc loadVK_NV_clip_space_w_scaling*(instance: VkInstance) = | |
| 11019 vkCmdSetViewportWScalingNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetViewportWScalingNV")) | |
| 11020 | |
| 11021 proc loadVK_NV_fill_rectangle*(instance: VkInstance) = | |
| 11022 discard | |
| 11023 | |
| 11024 proc loadVK_EXT_shader_image_atomic_int64*(instance: VkInstance) = | |
| 11025 loadVK_VERSION_1_1(instance) | |
| 11026 | |
| 11027 proc loadVK_EXT_ycbcr_image_arrays*(instance: VkInstance) = | |
| 11028 loadVK_VERSION_1_1(instance) | |
| 11029 | |
| 11030 # extension VK_EXT_calibrated_timestamps | |
| 11031 var | |
| 11032 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT*: proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32, pTimeDomains: ptr VkTimeDomainEXT): VkResult {.stdcall.} | |
| 11033 vkGetCalibratedTimestampsEXT*: proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT, pTimestamps: ptr uint64, pMaxDeviation: ptr uint64): VkResult {.stdcall.} | |
| 11034 proc loadVK_EXT_calibrated_timestamps*(instance: VkInstance) = | |
| 11035 loadVK_VERSION_1_1(instance) | |
| 11036 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = cast[proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32, pTimeDomains: ptr VkTimeDomainEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")) | |
| 11037 vkGetCalibratedTimestampsEXT = cast[proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT, pTimestamps: ptr uint64, pMaxDeviation: ptr uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT")) | |
| 11038 | |
| 11039 proc loadVK_EXT_attachment_feedback_loop_layout*(instance: VkInstance) = | |
| 11040 loadVK_VERSION_1_1(instance) | |
| 11041 | |
| 11042 proc loadVK_AMD_mixed_attachment_samples*(instance: VkInstance) = | |
| 11043 discard | |
| 11044 | |
| 11045 # extension VK_EXT_external_memory_host | |
| 11046 var | |
| 11047 vkGetMemoryHostPointerPropertiesEXT*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer, pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT): VkResult {.stdcall.} | |
| 11048 proc loadVK_EXT_external_memory_host*(instance: VkInstance) = | |
| 11049 loadVK_VERSION_1_1(instance) | |
| 11050 vkGetMemoryHostPointerPropertiesEXT = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer, pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT")) | |
| 11051 | |
| 11052 proc loadVK_ARM_shader_core_properties*(instance: VkInstance) = | |
| 11053 loadVK_VERSION_1_1(instance) | |
| 11054 | |
| 11055 # extension VK_EXT_shader_module_identifier | |
| 11056 var | |
| 11057 vkGetShaderModuleIdentifierEXT*: proc(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.} | |
| 11058 vkGetShaderModuleCreateInfoIdentifierEXT*: proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.} | |
| 11059 proc loadVK_EXT_shader_module_identifier*(instance: VkInstance) = | |
| 11060 loadVK_VERSION_1_1(instance) | |
| 11061 loadVK_VERSION_1_3(instance) | |
| 11062 vkGetShaderModuleIdentifierEXT = cast[proc(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetShaderModuleIdentifierEXT")) | |
| 11063 vkGetShaderModuleCreateInfoIdentifierEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo, pIdentifier: ptr VkShaderModuleIdentifierEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetShaderModuleCreateInfoIdentifierEXT")) | |
| 11064 | |
| 11065 proc loadVK_EXT_border_color_swizzle*(instance: VkInstance) = | |
| 11066 loadVK_EXT_custom_border_color(instance) | |
| 11067 | |
| 11068 # extension VK_NV_memory_decompression | |
| 11069 var | |
| 11070 vkCmdDecompressMemoryNV*: proc(commandBuffer: VkCommandBuffer, decompressRegionCount: uint32, pDecompressMemoryRegions: ptr VkDecompressMemoryRegionNV): void {.stdcall.} | |
| 11071 vkCmdDecompressMemoryIndirectCountNV*: proc(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: uint32): void {.stdcall.} | |
| 11072 proc loadVK_NV_memory_decompression*(instance: VkInstance) = | |
| 11073 loadVK_VERSION_1_1(instance) | |
| 11074 loadVK_VERSION_1_2(instance) | |
| 11075 vkCmdDecompressMemoryNV = cast[proc(commandBuffer: VkCommandBuffer, decompressRegionCount: uint32, pDecompressMemoryRegions: ptr VkDecompressMemoryRegionNV): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDecompressMemoryNV")) | |
| 11076 vkCmdDecompressMemoryIndirectCountNV = cast[proc(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDecompressMemoryIndirectCountNV")) | |
| 11077 | |
| 11078 proc loadVK_EXT_fragment_shader_interlock*(instance: VkInstance) = | |
| 11079 loadVK_VERSION_1_1(instance) | |
| 11080 | |
| 11081 # extension VK_NV_coverage_reduction_mode | |
| 11082 var | |
| 11083 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV*: proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32, pCombinations: ptr VkFramebufferMixedSamplesCombinationNV): VkResult {.stdcall.} | |
| 11084 proc loadVK_NV_coverage_reduction_mode*(instance: VkInstance) = | |
| 11085 loadVK_NV_framebuffer_mixed_samples(instance) | |
| 11086 loadVK_VERSION_1_1(instance) | |
| 11087 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = cast[proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32, pCombinations: ptr VkFramebufferMixedSamplesCombinationNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")) | |
| 11088 | |
| 11089 proc loadVK_NV_glsl_shader*(instance: VkInstance) = | |
| 11090 discard | |
| 11091 | |
| 11092 proc loadVK_KHR_shader_clock*(instance: VkInstance) = | |
| 11093 loadVK_VERSION_1_1(instance) | |
| 11094 | |
| 11095 # extension VK_QCOM_tile_properties | |
| 11096 var | |
| 11097 vkGetFramebufferTilePropertiesQCOM*: proc(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: ptr uint32, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.} | |
| 11098 vkGetDynamicRenderingTilePropertiesQCOM*: proc(device: VkDevice, pRenderingInfo: ptr VkRenderingInfo, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.} | |
| 11099 proc loadVK_QCOM_tile_properties*(instance: VkInstance) = | |
| 11100 loadVK_VERSION_1_1(instance) | |
| 11101 vkGetFramebufferTilePropertiesQCOM = cast[proc(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: ptr uint32, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetFramebufferTilePropertiesQCOM")) | |
| 11102 vkGetDynamicRenderingTilePropertiesQCOM = cast[proc(device: VkDevice, pRenderingInfo: ptr VkRenderingInfo, pProperties: ptr VkTilePropertiesQCOM): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDynamicRenderingTilePropertiesQCOM")) | |
| 11103 | |
| 11104 # extension VK_KHR_push_descriptor | |
| 11105 var | |
| 11106 vkCmdPushDescriptorSetKHR*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet): void {.stdcall.} | |
| 11107 vkCmdPushDescriptorSetWithTemplateKHR*: proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer): void {.stdcall.} | |
| 11108 proc loadVK_KHR_push_descriptor*(instance: VkInstance) = | |
| 11109 loadVK_VERSION_1_1(instance) | |
| 11110 vkCmdPushDescriptorSetKHR = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetKHR")) | |
| 11111 vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR")) | |
| 11112 vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR")) | |
| 11113 | |
| 11114 proc loadVK_NV_viewport_swizzle*(instance: VkInstance) = | |
| 11115 discard | |
| 11116 | |
| 11117 proc loadVK_NV_external_memory*(instance: VkInstance) = | |
| 11118 loadVK_NV_external_memory_capabilities(instance) | |
| 11119 | |
| 11120 proc loadVK_EXT_depth_clip_control*(instance: VkInstance) = | |
| 11121 loadVK_VERSION_1_1(instance) | |
| 11122 | |
| 11123 proc loadVK_EXT_validation_flags*(instance: VkInstance) = | |
| 11124 discard | |
| 11125 | |
| 11126 proc loadVK_EXT_conservative_rasterization*(instance: VkInstance) = | |
| 11127 loadVK_VERSION_1_1(instance) | |
| 11128 | |
| 11129 proc loadVK_AMD_gcn_shader*(instance: VkInstance) = | |
| 11130 discard | |
| 11131 | |
| 11132 # extension VK_INTEL_performance_query | |
| 11133 var | |
| 11134 vkInitializePerformanceApiINTEL*: proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL): VkResult {.stdcall.} | |
| 11135 vkUninitializePerformanceApiINTEL*: proc(device: VkDevice): void {.stdcall.} | |
| 11136 vkCmdSetPerformanceMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL): VkResult {.stdcall.} | |
| 11137 vkCmdSetPerformanceStreamMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL): VkResult {.stdcall.} | |
| 11138 vkCmdSetPerformanceOverrideINTEL*: proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL): VkResult {.stdcall.} | |
| 11139 vkAcquirePerformanceConfigurationINTEL*: proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: ptr VkPerformanceConfigurationINTEL): VkResult {.stdcall.} | |
| 11140 vkReleasePerformanceConfigurationINTEL*: proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.} | |
| 11141 vkQueueSetPerformanceConfigurationINTEL*: proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.} | |
| 11142 vkGetPerformanceParameterINTEL*: proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL): VkResult {.stdcall.} | |
| 11143 proc loadVK_INTEL_performance_query*(instance: VkInstance) = | |
| 11144 vkInitializePerformanceApiINTEL = cast[proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkInitializePerformanceApiINTEL")) | |
| 11145 vkUninitializePerformanceApiINTEL = cast[proc(device: VkDevice): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL")) | |
| 11146 vkCmdSetPerformanceMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceMarkerINTEL")) | |
| 11147 vkCmdSetPerformanceStreamMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceStreamMarkerINTEL")) | |
| 11148 vkCmdSetPerformanceOverrideINTEL = cast[proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceOverrideINTEL")) | |
| 11149 vkAcquirePerformanceConfigurationINTEL = cast[proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: ptr VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquirePerformanceConfigurationINTEL")) | |
| 11150 vkReleasePerformanceConfigurationINTEL = cast[proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleasePerformanceConfigurationINTEL")) | |
| 11151 vkQueueSetPerformanceConfigurationINTEL = cast[proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueSetPerformanceConfigurationINTEL")) | |
| 11152 vkGetPerformanceParameterINTEL = cast[proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL")) | |
| 11153 | |
| 11154 proc loadVK_EXT_primitives_generated_query*(instance: VkInstance) = | |
| 11155 loadVK_EXT_transform_feedback(instance) | |
| 11156 | |
| 11157 proc loadVK_AMD_pipeline_compiler_control*(instance: VkInstance) = | |
| 11158 discard | |
| 11159 | |
| 11160 proc loadVK_EXT_post_depth_coverage*(instance: VkInstance) = | |
| 11161 discard | |
| 11162 | |
| 11163 # extension VK_EXT_conditional_rendering | |
| 11164 var | |
| 11165 vkCmdBeginConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT): void {.stdcall.} | |
| 11166 vkCmdEndConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.} | |
| 11167 proc loadVK_EXT_conditional_rendering*(instance: VkInstance) = | |
| 11168 loadVK_VERSION_1_1(instance) | |
| 11169 vkCmdBeginConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginConditionalRenderingEXT")) | |
| 11170 vkCmdEndConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndConditionalRenderingEXT")) | |
| 11171 | |
| 11172 proc loadVK_QCOM_multiview_per_view_viewports*(instance: VkInstance) = | |
| 11173 loadVK_VERSION_1_1(instance) | |
| 11174 | |
| 11175 # extension VK_EXT_multi_draw | |
| 11176 var | |
| 11177 vkCmdDrawMultiEXT*: proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pVertexInfo: ptr VkMultiDrawInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32): void {.stdcall.} | |
| 11178 vkCmdDrawMultiIndexedEXT*: proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pIndexInfo: ptr VkMultiDrawIndexedInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32, pVertexOffset: ptr int32): void {.stdcall.} | |
| 11179 proc loadVK_EXT_multi_draw*(instance: VkInstance) = | |
| 11180 loadVK_VERSION_1_1(instance) | |
| 11181 vkCmdDrawMultiEXT = cast[proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pVertexInfo: ptr VkMultiDrawInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMultiEXT")) | |
| 11182 vkCmdDrawMultiIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, drawCount: uint32, pIndexInfo: ptr VkMultiDrawIndexedInfoEXT, instanceCount: uint32, firstInstance: uint32, stride: uint32, pVertexOffset: ptr int32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawMultiIndexedEXT")) | |
| 11183 | |
| 11184 proc loadVK_NV_fragment_coverage_to_color*(instance: VkInstance) = | |
| 11185 discard | |
| 11186 | |
| 11187 proc loadVK_EXT_load_store_op_none*(instance: VkInstance) = | |
| 11188 discard | |
| 11189 | |
| 11190 proc loadVK_EXT_validation_features*(instance: VkInstance) = | |
| 11191 discard | |
| 11192 | |
| 11193 proc loadVK_KHR_workgroup_memory_explicit_layout*(instance: VkInstance) = | |
| 11194 loadVK_VERSION_1_1(instance) | |
| 11195 | |
| 11196 proc loadVK_EXT_index_type_uint8*(instance: VkInstance) = | |
| 11197 loadVK_VERSION_1_1(instance) | |
| 11198 | |
| 11199 proc loadVK_GOOGLE_decorate_string*(instance: VkInstance) = | |
| 11200 discard | |
| 11201 | |
| 11202 proc loadVK_EXT_shader_atomic_float*(instance: VkInstance) = | |
| 11203 loadVK_VERSION_1_1(instance) | |
| 11204 | |
| 11205 # extension VK_EXT_pipeline_properties | |
| 11206 var | |
| 11207 vkGetPipelinePropertiesEXT*: proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoEXT, pPipelineProperties: ptr VkBaseOutStructure): VkResult {.stdcall.} | |
| 11208 proc loadVK_EXT_pipeline_properties*(instance: VkInstance) = | |
| 11209 loadVK_VERSION_1_1(instance) | |
| 11210 vkGetPipelinePropertiesEXT = cast[proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoEXT, pPipelineProperties: ptr VkBaseOutStructure): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPipelinePropertiesEXT")) | |
| 11211 | |
| 11212 proc loadVK_EXT_graphics_pipeline_library*(instance: VkInstance) = | |
| 11213 loadVK_VERSION_1_1(instance) | |
| 11214 loadVK_KHR_pipeline_library(instance) | |
| 11215 | |
| 11216 # extension VK_KHR_surface | |
| 11217 var | |
| 11218 vkDestroySurfaceKHR*: proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11219 vkGetPhysicalDeviceSurfaceSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32): VkResult {.stdcall.} | |
| 11220 vkGetPhysicalDeviceSurfaceCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR): VkResult {.stdcall.} | |
| 11221 vkGetPhysicalDeviceSurfaceFormatsKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormatKHR): VkResult {.stdcall.} | |
| 11222 vkGetPhysicalDeviceSurfacePresentModesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32, pPresentModes: ptr VkPresentModeKHR): VkResult {.stdcall.} | |
| 11223 proc loadVK_KHR_surface*(instance: VkInstance) = | |
| 11224 vkDestroySurfaceKHR = cast[proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR")) | |
| 11225 vkGetPhysicalDeviceSurfaceSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR")) | |
| 11226 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) | |
| 11227 vkGetPhysicalDeviceSurfaceFormatsKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormatKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR")) | |
| 11228 vkGetPhysicalDeviceSurfacePresentModesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32, pPresentModes: ptr VkPresentModeKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR")) | |
| 11229 | |
| 11230 proc loadVK_AMD_gpu_shader_half_float*(instance: VkInstance) = | |
| 11231 discard | |
| 11232 | |
| 11233 # extension VK_KHR_deferred_host_operations | |
| 11234 var | |
| 11235 vkCreateDeferredOperationKHR*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks, pDeferredOperation: ptr VkDeferredOperationKHR): VkResult {.stdcall.} | |
| 11236 vkDestroyDeferredOperationKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11237 vkGetDeferredOperationMaxConcurrencyKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.} | |
| 11238 vkGetDeferredOperationResultKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.} | |
| 11239 vkDeferredOperationJoinKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.} | |
| 11240 proc loadVK_KHR_deferred_host_operations*(instance: VkInstance) = | |
| 11241 vkCreateDeferredOperationKHR = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks, pDeferredOperation: ptr VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDeferredOperationKHR")) | |
| 11242 vkDestroyDeferredOperationKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDeferredOperationKHR")) | |
| 11243 vkGetDeferredOperationMaxConcurrencyKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR")) | |
| 11244 vkGetDeferredOperationResultKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR")) | |
| 11245 vkDeferredOperationJoinKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDeferredOperationJoinKHR")) | |
| 11246 | |
| 11247 proc loadVK_NV_dedicated_allocation*(instance: VkInstance) = | |
| 11248 discard | |
| 11249 | |
| 11250 # extension VK_NVX_image_view_handle | |
| 11251 var | |
| 11252 vkGetImageViewHandleNVX*: proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX): uint32 {.stdcall.} | |
| 11253 vkGetImageViewAddressNVX*: proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX): VkResult {.stdcall.} | |
| 11254 proc loadVK_NVX_image_view_handle*(instance: VkInstance) = | |
| 11255 vkGetImageViewHandleNVX = cast[proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX): uint32 {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageViewHandleNVX")) | |
| 11256 vkGetImageViewAddressNVX = cast[proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetImageViewAddressNVX")) | |
| 11257 | |
| 11258 proc loadVK_EXT_non_seamless_cube_map*(instance: VkInstance) = | |
| 11259 loadVK_VERSION_1_1(instance) | |
| 11260 | |
| 11261 proc loadVK_QCOM_render_pass_store_ops*(instance: VkInstance) = | |
| 11262 discard | |
| 11263 | |
| 11264 # extension VK_EXT_device_fault | |
| 11265 var | |
| 11266 vkGetDeviceFaultInfoEXT*: proc(device: VkDevice, pFaultCounts: ptr VkDeviceFaultCountsEXT, pFaultInfo: ptr VkDeviceFaultInfoEXT): VkResult {.stdcall.} | |
| 11267 proc loadVK_EXT_device_fault*(instance: VkInstance) = | |
| 11268 loadVK_VERSION_1_1(instance) | |
| 11269 vkGetDeviceFaultInfoEXT = cast[proc(device: VkDevice, pFaultCounts: ptr VkDeviceFaultCountsEXT, pFaultInfo: ptr VkDeviceFaultInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceFaultInfoEXT")) | |
| 11270 | |
| 11271 proc loadVK_EXT_mutable_descriptor_type*(instance: VkInstance) = | |
| 11272 loadVK_VERSION_1_1(instance) | |
| 11273 | |
| 11274 # extension VK_EXT_color_write_enable | |
| 11275 var | |
| 11276 vkCmdSetColorWriteEnableEXT*: proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pColorWriteEnables: ptr VkBool32): void {.stdcall.} | |
| 11277 proc loadVK_EXT_color_write_enable*(instance: VkInstance) = | |
| 11278 loadVK_VERSION_1_1(instance) | |
| 11279 vkCmdSetColorWriteEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pColorWriteEnables: ptr VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetColorWriteEnableEXT")) | |
| 11280 | |
| 11281 proc loadVK_SEC_amigo_profiling*(instance: VkInstance) = | |
| 11282 loadVK_VERSION_1_1(instance) | |
| 11283 | |
| 11284 # extension VK_NVX_binary_import | |
| 11285 var | |
| 11286 vkCreateCuModuleNVX*: proc(device: VkDevice, pCreateInfo: ptr VkCuModuleCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pModule: ptr VkCuModuleNVX): VkResult {.stdcall.} | |
| 11287 vkCreateCuFunctionNVX*: proc(device: VkDevice, pCreateInfo: ptr VkCuFunctionCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pFunction: ptr VkCuFunctionNVX): VkResult {.stdcall.} | |
| 11288 vkDestroyCuModuleNVX*: proc(device: VkDevice, module: VkCuModuleNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11289 vkDestroyCuFunctionNVX*: proc(device: VkDevice, function: VkCuFunctionNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11290 vkCmdCuLaunchKernelNVX*: proc(commandBuffer: VkCommandBuffer, pLaunchInfo: ptr VkCuLaunchInfoNVX): void {.stdcall.} | |
| 11291 proc loadVK_NVX_binary_import*(instance: VkInstance) = | |
| 11292 vkCreateCuModuleNVX = cast[proc(device: VkDevice, pCreateInfo: ptr VkCuModuleCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pModule: ptr VkCuModuleNVX): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateCuModuleNVX")) | |
| 11293 vkCreateCuFunctionNVX = cast[proc(device: VkDevice, pCreateInfo: ptr VkCuFunctionCreateInfoNVX, pAllocator: ptr VkAllocationCallbacks, pFunction: ptr VkCuFunctionNVX): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateCuFunctionNVX")) | |
| 11294 vkDestroyCuModuleNVX = cast[proc(device: VkDevice, module: VkCuModuleNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyCuModuleNVX")) | |
| 11295 vkDestroyCuFunctionNVX = cast[proc(device: VkDevice, function: VkCuFunctionNVX, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyCuFunctionNVX")) | |
| 11296 vkCmdCuLaunchKernelNVX = cast[proc(commandBuffer: VkCommandBuffer, pLaunchInfo: ptr VkCuLaunchInfoNVX): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCuLaunchKernelNVX")) | |
| 11297 | |
| 11298 proc loadVK_NV_representative_fragment_test*(instance: VkInstance) = | |
| 11299 loadVK_VERSION_1_1(instance) | |
| 11300 | |
| 11301 # extension VK_EXT_validation_cache | |
| 11302 var | |
| 11303 vkCreateValidationCacheEXT*: proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pValidationCache: ptr VkValidationCacheEXT): VkResult {.stdcall.} | |
| 11304 vkDestroyValidationCacheEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11305 vkMergeValidationCachesEXT*: proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT): VkResult {.stdcall.} | |
| 11306 vkGetValidationCacheDataEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.} | |
| 11307 proc loadVK_EXT_validation_cache*(instance: VkInstance) = | |
| 11308 vkCreateValidationCacheEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pValidationCache: ptr VkValidationCacheEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateValidationCacheEXT")) | |
| 11309 vkDestroyValidationCacheEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyValidationCacheEXT")) | |
| 11310 vkMergeValidationCachesEXT = cast[proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkMergeValidationCachesEXT")) | |
| 11311 vkGetValidationCacheDataEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetValidationCacheDataEXT")) | |
| 11312 | |
| 11313 proc loadVK_NV_inherited_viewport_scissor*(instance: VkInstance) = | |
| 11314 loadVK_VERSION_1_1(instance) | |
| 11315 | |
| 11316 proc loadVK_EXT_legacy_dithering*(instance: VkInstance) = | |
| 11317 loadVK_VERSION_1_1(instance) | |
| 11318 | |
| 11319 proc loadVK_EXT_physical_device_drm*(instance: VkInstance) = | |
| 11320 loadVK_VERSION_1_1(instance) | |
| 11321 | |
| 11322 proc loadVK_EXT_pipeline_protected_access*(instance: VkInstance) = | |
| 11323 loadVK_VERSION_1_1(instance) | |
| 11324 | |
| 11325 # extension VK_EXT_discard_rectangles | |
| 11326 var | |
| 11327 vkCmdSetDiscardRectangleEXT*: proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D): void {.stdcall.} | |
| 11328 vkCmdSetDiscardRectangleEnableEXT*: proc(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32): void {.stdcall.} | |
| 11329 vkCmdSetDiscardRectangleModeEXT*: proc(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT): void {.stdcall.} | |
| 11330 proc loadVK_EXT_discard_rectangles*(instance: VkInstance) = | |
| 11331 loadVK_VERSION_1_1(instance) | |
| 11332 vkCmdSetDiscardRectangleEXT = cast[proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEXT")) | |
| 11333 vkCmdSetDiscardRectangleEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEnableEXT")) | |
| 11334 vkCmdSetDiscardRectangleModeEXT = cast[proc(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleModeEXT")) | |
| 11335 | |
| 11336 proc loadVK_EXT_shader_stencil_export*(instance: VkInstance) = | |
| 11337 discard | |
| 11338 | |
| 11339 # extension VK_NV_external_memory_rdma | |
| 11340 var | |
| 11341 vkGetMemoryRemoteAddressNV*: proc(device: VkDevice, pMemoryGetRemoteAddressInfo: ptr VkMemoryGetRemoteAddressInfoNV, pAddress: ptr VkRemoteAddressNV): VkResult {.stdcall.} | |
| 11342 proc loadVK_NV_external_memory_rdma*(instance: VkInstance) = | |
| 11343 loadVK_VERSION_1_1(instance) | |
| 11344 vkGetMemoryRemoteAddressNV = cast[proc(device: VkDevice, pMemoryGetRemoteAddressInfo: ptr VkMemoryGetRemoteAddressInfoNV, pAddress: ptr VkRemoteAddressNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV")) | |
| 11345 | |
| 11346 proc loadVK_ARM_shader_core_builtins*(instance: VkInstance) = | |
| 11347 loadVK_VERSION_1_1(instance) | |
| 11348 | |
| 11349 proc loadVK_QCOM_multiview_per_view_render_areas*(instance: VkInstance) = | |
| 11350 discard | |
| 11351 | |
| 11352 proc loadVK_LUNARG_direct_driver_loading*(instance: VkInstance) = | |
| 11353 discard | |
| 11354 | |
| 11355 proc loadVK_AMD_shader_explicit_vertex_parameter*(instance: VkInstance) = | |
| 11356 discard | |
| 11357 | |
| 11358 # extension VK_EXT_headless_surface | |
| 11359 var | |
| 11360 vkCreateHeadlessSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.} | |
| 11361 proc loadVK_EXT_headless_surface*(instance: VkInstance) = | |
| 11362 loadVK_KHR_surface(instance) | |
| 11363 vkCreateHeadlessSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateHeadlessSurfaceEXT")) | |
| 11364 | |
| 11365 proc loadVK_NV_shader_sm_builtins*(instance: VkInstance) = | |
| 11366 loadVK_VERSION_1_1(instance) | |
| 11367 | |
| 11368 proc loadVK_EXT_shader_subgroup_vote*(instance: VkInstance) = | |
| 11369 discard | |
| 11370 | |
| 11371 # extension VK_NV_copy_memory_indirect | |
| 11372 var | |
| 11373 vkCmdCopyMemoryIndirectNV*: proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32): void {.stdcall.} | |
| 11374 vkCmdCopyMemoryToImageIndirectNV*: proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: ptr VkImageSubresourceLayers): void {.stdcall.} | |
| 11375 proc loadVK_NV_copy_memory_indirect*(instance: VkInstance) = | |
| 11376 loadVK_VERSION_1_1(instance) | |
| 11377 loadVK_VERSION_1_2(instance) | |
| 11378 vkCmdCopyMemoryIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryIndirectNV")) | |
| 11379 vkCmdCopyMemoryToImageIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32, stride: uint32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: ptr VkImageSubresourceLayers): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToImageIndirectNV")) | |
| 11380 | |
| 11381 proc loadVK_EXT_astc_decode_mode*(instance: VkInstance) = | |
| 11382 loadVK_VERSION_1_1(instance) | |
| 11383 | |
| 11384 # extension VK_KHR_get_surface_capabilities2 | |
| 11385 var | |
| 11386 vkGetPhysicalDeviceSurfaceCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR): VkResult {.stdcall.} | |
| 11387 vkGetPhysicalDeviceSurfaceFormats2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormat2KHR): VkResult {.stdcall.} | |
| 11388 proc loadVK_KHR_get_surface_capabilities2*(instance: VkInstance) = | |
| 11389 loadVK_KHR_surface(instance) | |
| 11390 vkGetPhysicalDeviceSurfaceCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) | |
| 11391 vkGetPhysicalDeviceSurfaceFormats2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: ptr uint32, pSurfaceFormats: ptr VkSurfaceFormat2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR")) | |
| 11392 | |
| 11393 # extension VK_HUAWEI_cluster_culling_shader | |
| 11394 var | |
| 11395 vkCmdDrawClusterHUAWEI*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.} | |
| 11396 vkCmdDrawClusterIndirectHUAWEI*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.} | |
| 11397 proc loadVK_HUAWEI_cluster_culling_shader*(instance: VkInstance) = | |
| 11398 loadVK_VERSION_1_1(instance) | |
| 11399 vkCmdDrawClusterHUAWEI = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawClusterHUAWEI")) | |
| 11400 vkCmdDrawClusterIndirectHUAWEI = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdDrawClusterIndirectHUAWEI")) | |
| 11401 | |
| 11402 proc loadVK_KHR_surface_protected_capabilities*(instance: VkInstance) = | |
| 11403 loadVK_VERSION_1_1(instance) | |
| 11404 loadVK_KHR_get_surface_capabilities2(instance) | |
| 11405 | |
| 11406 proc loadVK_NV_shader_image_footprint*(instance: VkInstance) = | |
| 11407 loadVK_VERSION_1_1(instance) | |
| 11408 | |
| 11409 proc loadVK_NV_compute_shader_derivatives*(instance: VkInstance) = | |
| 11410 loadVK_VERSION_1_1(instance) | |
| 11411 | |
| 11412 proc loadVK_QCOM_fragment_density_map_offset*(instance: VkInstance) = | |
| 11413 loadVK_VERSION_1_1(instance) | |
| 11414 loadVK_EXT_fragment_density_map(instance) | |
| 11415 | |
| 11416 proc loadVK_EXT_shader_atomic_float2*(instance: VkInstance) = | |
| 11417 loadVK_EXT_shader_atomic_float(instance) | |
| 11418 | |
| 11419 # extension VK_EXT_pageable_device_local_memory | |
| 11420 var | |
| 11421 vkSetDeviceMemoryPriorityEXT*: proc(device: VkDevice, memory: VkDeviceMemory, priority: float32): void {.stdcall.} | |
| 11422 proc loadVK_EXT_pageable_device_local_memory*(instance: VkInstance) = | |
| 11423 loadVK_EXT_memory_priority(instance) | |
| 11424 vkSetDeviceMemoryPriorityEXT = cast[proc(device: VkDevice, memory: VkDeviceMemory, priority: float32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDeviceMemoryPriorityEXT")) | |
| 11425 | |
| 11426 # extension VK_KHR_swapchain | |
| 11427 var | |
| 11428 vkCreateSwapchainKHR*: proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchain: ptr VkSwapchainKHR): VkResult {.stdcall.} | |
| 11429 vkDestroySwapchainKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11430 vkGetSwapchainImagesKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32, pSwapchainImages: ptr VkImage): VkResult {.stdcall.} | |
| 11431 vkAcquireNextImageKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32): VkResult {.stdcall.} | |
| 11432 vkQueuePresentKHR*: proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR): VkResult {.stdcall.} | |
| 11433 vkGetDeviceGroupPresentCapabilitiesKHR*: proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR): VkResult {.stdcall.} | |
| 11434 vkGetDeviceGroupSurfacePresentModesKHR*: proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR): VkResult {.stdcall.} | |
| 11435 vkGetPhysicalDevicePresentRectanglesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32, pRects: ptr VkRect2D): VkResult {.stdcall.} | |
| 11436 vkAcquireNextImage2KHR*: proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR, pImageIndex: ptr uint32): VkResult {.stdcall.} | |
| 11437 proc loadVK_KHR_swapchain*(instance: VkInstance) = | |
| 11438 loadVK_KHR_surface(instance) | |
| 11439 vkCreateSwapchainKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchain: ptr VkSwapchainKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSwapchainKHR")) | |
| 11440 vkDestroySwapchainKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroySwapchainKHR")) | |
| 11441 vkGetSwapchainImagesKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32, pSwapchainImages: ptr VkImage): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR")) | |
| 11442 vkAcquireNextImageKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireNextImageKHR")) | |
| 11443 vkQueuePresentKHR = cast[proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueuePresentKHR")) | |
| 11444 vkGetDeviceGroupPresentCapabilitiesKHR = cast[proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPresentCapabilitiesKHR")) | |
| 11445 vkGetDeviceGroupSurfacePresentModesKHR = cast[proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModesKHR")) | |
| 11446 vkGetPhysicalDevicePresentRectanglesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32, pRects: ptr VkRect2D): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR")) | |
| 11447 vkAcquireNextImage2KHR = cast[proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR, pImageIndex: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireNextImage2KHR")) | |
| 11448 | |
| 11449 proc loadVK_EXT_fragment_density_map2*(instance: VkInstance) = | |
| 11450 loadVK_EXT_fragment_density_map(instance) | |
| 11451 | |
| 11452 # extension VK_NV_fragment_shading_rate_enums | |
| 11453 var | |
| 11454 vkCmdSetFragmentShadingRateEnumNV*: proc(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.} | |
| 11455 proc loadVK_NV_fragment_shading_rate_enums*(instance: VkInstance) = | |
| 11456 loadVK_KHR_fragment_shading_rate(instance) | |
| 11457 vkCmdSetFragmentShadingRateEnumNV = cast[proc(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: array[2, VkFragmentShadingRateCombinerOpKHR]): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateEnumNV")) | |
| 11458 | |
| 11459 # extension VK_AMD_display_native_hdr | |
| 11460 var | |
| 11461 vkSetLocalDimmingAMD*: proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.} | |
| 11462 proc loadVK_AMD_display_native_hdr*(instance: VkInstance) = | |
| 11463 loadVK_VERSION_1_1(instance) | |
| 11464 loadVK_KHR_get_surface_capabilities2(instance) | |
| 11465 loadVK_KHR_swapchain(instance) | |
| 11466 vkSetLocalDimmingAMD = cast[proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetLocalDimmingAMD")) | |
| 11467 | |
| 11468 proc loadVK_NV_present_barrier*(instance: VkInstance) = | |
| 11469 loadVK_VERSION_1_1(instance) | |
| 11470 loadVK_KHR_surface(instance) | |
| 11471 loadVK_KHR_get_surface_capabilities2(instance) | |
| 11472 loadVK_KHR_swapchain(instance) | |
| 11473 | |
| 11474 proc loadVK_QCOM_rotated_copy_commands*(instance: VkInstance) = | |
| 11475 loadVK_KHR_swapchain(instance) | |
| 11476 loadVK_VERSION_1_3(instance) | |
| 11477 | |
| 11478 proc loadVK_EXT_surface_maintenance1*(instance: VkInstance) = | |
| 11479 loadVK_KHR_surface(instance) | |
| 11480 loadVK_KHR_get_surface_capabilities2(instance) | |
| 11481 | |
| 11482 # extension VK_KHR_acceleration_structure | |
| 11483 var | |
| 11484 vkCreateAccelerationStructureKHR*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureKHR): VkResult {.stdcall.} | |
| 11485 vkDestroyAccelerationStructureKHR*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11486 vkCmdBuildAccelerationStructuresKHR*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): void {.stdcall.} | |
| 11487 vkCmdBuildAccelerationStructuresIndirectKHR*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: ptr VkDeviceAddress, pIndirectStrides: ptr uint32, ppMaxPrimitiveCounts: ptr ptr uint32): void {.stdcall.} | |
| 11488 vkBuildAccelerationStructuresKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): VkResult {.stdcall.} | |
| 11489 vkCopyAccelerationStructureKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureInfoKHR): VkResult {.stdcall.} | |
| 11490 vkCopyAccelerationStructureToMemoryKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): VkResult {.stdcall.} | |
| 11491 vkCopyMemoryToAccelerationStructureKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): VkResult {.stdcall.} | |
| 11492 vkWriteAccelerationStructuresPropertiesKHR*: proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: csize_t, pData: pointer, stride: csize_t): VkResult {.stdcall.} | |
| 11493 vkCmdCopyAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR): void {.stdcall.} | |
| 11494 vkCmdCopyAccelerationStructureToMemoryKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): void {.stdcall.} | |
| 11495 vkCmdCopyMemoryToAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): void {.stdcall.} | |
| 11496 vkGetAccelerationStructureDeviceAddressKHR*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR): VkDeviceAddress {.stdcall.} | |
| 11497 vkCmdWriteAccelerationStructuresPropertiesKHR*: proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.} | |
| 11498 vkGetDeviceAccelerationStructureCompatibilityKHR*: proc(device: VkDevice, pVersionInfo: ptr VkAccelerationStructureVersionInfoKHR, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.} | |
| 11499 vkGetAccelerationStructureBuildSizesKHR*: proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: ptr uint32, pSizeInfo: ptr VkAccelerationStructureBuildSizesInfoKHR): void {.stdcall.} | |
| 11500 proc loadVK_KHR_acceleration_structure*(instance: VkInstance) = | |
| 11501 loadVK_VERSION_1_1(instance) | |
| 11502 loadVK_VERSION_1_2(instance) | |
| 11503 loadVK_VERSION_1_2(instance) | |
| 11504 loadVK_KHR_deferred_host_operations(instance) | |
| 11505 vkCreateAccelerationStructureKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureKHR")) | |
| 11506 vkDestroyAccelerationStructureKHR = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureKHR")) | |
| 11507 vkCmdBuildAccelerationStructuresKHR = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR")) | |
| 11508 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")) | |
| 11509 vkBuildAccelerationStructuresKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ptr ptr VkAccelerationStructureBuildRangeInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBuildAccelerationStructuresKHR")) | |
| 11510 vkCopyAccelerationStructureKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR")) | |
| 11511 vkCopyAccelerationStructureToMemoryKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR")) | |
| 11512 vkCopyMemoryToAccelerationStructureKHR = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMemoryToAccelerationStructureKHR")) | |
| 11513 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")) | |
| 11514 vkCmdCopyAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR")) | |
| 11515 vkCmdCopyAccelerationStructureToMemoryKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR")) | |
| 11516 vkCmdCopyMemoryToAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToAccelerationStructureKHR")) | |
| 11517 vkGetAccelerationStructureDeviceAddressKHR = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR): VkDeviceAddress {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureDeviceAddressKHR")) | |
| 11518 vkCmdWriteAccelerationStructuresPropertiesKHR = cast[proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesKHR")) | |
| 11519 vkGetDeviceAccelerationStructureCompatibilityKHR = cast[proc(device: VkDevice, pVersionInfo: ptr VkAccelerationStructureVersionInfoKHR, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceAccelerationStructureCompatibilityKHR")) | |
| 11520 vkGetAccelerationStructureBuildSizesKHR = cast[proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: ptr uint32, pSizeInfo: ptr VkAccelerationStructureBuildSizesInfoKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureBuildSizesKHR")) | |
| 11521 | |
| 11522 # extension VK_GOOGLE_display_timing | |
| 11523 var | |
| 11524 vkGetRefreshCycleDurationGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE): VkResult {.stdcall.} | |
| 11525 vkGetPastPresentationTimingGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32, pPresentationTimings: ptr VkPastPresentationTimingGOOGLE): VkResult {.stdcall.} | |
| 11526 proc loadVK_GOOGLE_display_timing*(instance: VkInstance) = | |
| 11527 loadVK_KHR_swapchain(instance) | |
| 11528 vkGetRefreshCycleDurationGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE")) | |
| 11529 vkGetPastPresentationTimingGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32, pPresentationTimings: ptr VkPastPresentationTimingGOOGLE): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE")) | |
| 11530 | |
| 11531 proc loadVK_QCOM_render_pass_transform*(instance: VkInstance) = | |
| 11532 loadVK_KHR_swapchain(instance) | |
| 11533 loadVK_KHR_surface(instance) | |
| 11534 | |
| 11535 proc loadVK_GOOGLE_surfaceless_query*(instance: VkInstance) = | |
| 11536 loadVK_KHR_surface(instance) | |
| 11537 | |
| 11538 proc loadVK_EXT_image_compression_control_swapchain*(instance: VkInstance) = | |
| 11539 loadVK_EXT_image_compression_control(instance) | |
| 11540 | |
| 11541 # extension VK_KHR_display | |
| 11542 var | |
| 11543 vkGetPhysicalDeviceDisplayPropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPropertiesKHR): VkResult {.stdcall.} | |
| 11544 vkGetPhysicalDeviceDisplayPlanePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlanePropertiesKHR): VkResult {.stdcall.} | |
| 11545 vkGetDisplayPlaneSupportedDisplaysKHR*: proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32, pDisplays: ptr VkDisplayKHR): VkResult {.stdcall.} | |
| 11546 vkGetDisplayModePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModePropertiesKHR): VkResult {.stdcall.} | |
| 11547 vkCreateDisplayModeKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pMode: ptr VkDisplayModeKHR): VkResult {.stdcall.} | |
| 11548 vkGetDisplayPlaneCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR): VkResult {.stdcall.} | |
| 11549 vkCreateDisplayPlaneSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.} | |
| 11550 proc loadVK_KHR_display*(instance: VkInstance) = | |
| 11551 loadVK_KHR_surface(instance) | |
| 11552 vkGetPhysicalDeviceDisplayPropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR")) | |
| 11553 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlanePropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) | |
| 11554 vkGetDisplayPlaneSupportedDisplaysKHR = cast[proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32, pDisplays: ptr VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR")) | |
| 11555 vkGetDisplayModePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModePropertiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayModePropertiesKHR")) | |
| 11556 vkCreateDisplayModeKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pMode: ptr VkDisplayModeKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDisplayModeKHR")) | |
| 11557 vkGetDisplayPlaneCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR")) | |
| 11558 vkCreateDisplayPlaneSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSurface: ptr VkSurfaceKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDisplayPlaneSurfaceKHR")) | |
| 11559 | |
| 11560 # extension VK_EXT_swapchain_maintenance1 | |
| 11561 var | |
| 11562 vkReleaseSwapchainImagesEXT*: proc(device: VkDevice, pReleaseInfo: ptr VkReleaseSwapchainImagesInfoEXT): VkResult {.stdcall.} | |
| 11563 proc loadVK_EXT_swapchain_maintenance1*(instance: VkInstance) = | |
| 11564 loadVK_KHR_swapchain(instance) | |
| 11565 loadVK_EXT_surface_maintenance1(instance) | |
| 11566 loadVK_VERSION_1_1(instance) | |
| 11567 vkReleaseSwapchainImagesEXT = cast[proc(device: VkDevice, pReleaseInfo: ptr VkReleaseSwapchainImagesInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleaseSwapchainImagesEXT")) | |
| 11568 | |
| 11569 # extension VK_EXT_direct_mode_display | |
| 11570 var | |
| 11571 vkReleaseDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.} | |
| 11572 proc loadVK_EXT_direct_mode_display*(instance: VkInstance) = | |
| 11573 loadVK_KHR_display(instance) | |
| 11574 vkReleaseDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT")) | |
| 11575 | |
| 11576 proc loadVK_KHR_swapchain_mutable_format*(instance: VkInstance) = | |
| 11577 loadVK_KHR_swapchain(instance) | |
| 11578 loadVK_VERSION_1_1(instance) | |
| 11579 loadVK_VERSION_1_2(instance) | |
| 11580 | |
| 11581 proc loadVK_EXT_swapchain_colorspace*(instance: VkInstance) = | |
| 11582 loadVK_KHR_surface(instance) | |
| 11583 | |
| 11584 # extension VK_EXT_opacity_micromap | |
| 11585 var | |
| 11586 vkCreateMicromapEXT*: proc(device: VkDevice, pCreateInfo: ptr VkMicromapCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMicromap: ptr VkMicromapEXT): VkResult {.stdcall.} | |
| 11587 vkDestroyMicromapEXT*: proc(device: VkDevice, micromap: VkMicromapEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11588 vkCmdBuildMicromapsEXT*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): void {.stdcall.} | |
| 11589 vkBuildMicromapsEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): VkResult {.stdcall.} | |
| 11590 vkCopyMicromapEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapInfoEXT): VkResult {.stdcall.} | |
| 11591 vkCopyMicromapToMemoryEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): VkResult {.stdcall.} | |
| 11592 vkCopyMemoryToMicromapEXT*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): VkResult {.stdcall.} | |
| 11593 vkWriteMicromapsPropertiesEXT*: proc(device: VkDevice, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, dataSize: csize_t, pData: pointer, stride: csize_t): VkResult {.stdcall.} | |
| 11594 vkCmdCopyMicromapEXT*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapInfoEXT): void {.stdcall.} | |
| 11595 vkCmdCopyMicromapToMemoryEXT*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): void {.stdcall.} | |
| 11596 vkCmdCopyMemoryToMicromapEXT*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): void {.stdcall.} | |
| 11597 vkCmdWriteMicromapsPropertiesEXT*: proc(commandBuffer: VkCommandBuffer, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.} | |
| 11598 vkGetDeviceMicromapCompatibilityEXT*: proc(device: VkDevice, pVersionInfo: ptr VkMicromapVersionInfoEXT, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.} | |
| 11599 vkGetMicromapBuildSizesEXT*: proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkMicromapBuildInfoEXT, pSizeInfo: ptr VkMicromapBuildSizesInfoEXT): void {.stdcall.} | |
| 11600 proc loadVK_EXT_opacity_micromap*(instance: VkInstance) = | |
| 11601 loadVK_KHR_acceleration_structure(instance) | |
| 11602 loadVK_VERSION_1_3(instance) | |
| 11603 vkCreateMicromapEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkMicromapCreateInfoEXT, pAllocator: ptr VkAllocationCallbacks, pMicromap: ptr VkMicromapEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateMicromapEXT")) | |
| 11604 vkDestroyMicromapEXT = cast[proc(device: VkDevice, micromap: VkMicromapEXT, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyMicromapEXT")) | |
| 11605 vkCmdBuildMicromapsEXT = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBuildMicromapsEXT")) | |
| 11606 vkBuildMicromapsEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32, pInfos: ptr VkMicromapBuildInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBuildMicromapsEXT")) | |
| 11607 vkCopyMicromapEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMicromapEXT")) | |
| 11608 vkCopyMicromapToMemoryEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMicromapToMemoryEXT")) | |
| 11609 vkCopyMemoryToMicromapEXT = cast[proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCopyMemoryToMicromapEXT")) | |
| 11610 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")) | |
| 11611 vkCmdCopyMicromapEXT = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMicromapEXT")) | |
| 11612 vkCmdCopyMicromapToMemoryEXT = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMicromapToMemoryInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMicromapToMemoryEXT")) | |
| 11613 vkCmdCopyMemoryToMicromapEXT = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToMicromapInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToMicromapEXT")) | |
| 11614 vkCmdWriteMicromapsPropertiesEXT = cast[proc(commandBuffer: VkCommandBuffer, micromapCount: uint32, pMicromaps: ptr VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteMicromapsPropertiesEXT")) | |
| 11615 vkGetDeviceMicromapCompatibilityEXT = cast[proc(device: VkDevice, pVersionInfo: ptr VkMicromapVersionInfoEXT, pCompatibility: ptr VkAccelerationStructureCompatibilityKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDeviceMicromapCompatibilityEXT")) | |
| 11616 vkGetMicromapBuildSizesEXT = cast[proc(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: ptr VkMicromapBuildInfoEXT, pSizeInfo: ptr VkMicromapBuildSizesInfoEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetMicromapBuildSizesEXT")) | |
| 11617 | |
| 11618 proc loadVK_KHR_incremental_present*(instance: VkInstance) = | |
| 11619 loadVK_KHR_swapchain(instance) | |
| 11620 | |
| 11621 # extension VK_KHR_shared_presentable_image | |
| 11622 var | |
| 11623 vkGetSwapchainStatusKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.} | |
| 11624 proc loadVK_KHR_shared_presentable_image*(instance: VkInstance) = | |
| 11625 loadVK_KHR_swapchain(instance) | |
| 11626 loadVK_VERSION_1_1(instance) | |
| 11627 loadVK_KHR_get_surface_capabilities2(instance) | |
| 11628 vkGetSwapchainStatusKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSwapchainStatusKHR")) | |
| 11629 | |
| 11630 # extension VK_EXT_hdr_metadata | |
| 11631 var | |
| 11632 vkSetHdrMetadataEXT*: proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR, pMetadata: ptr VkHdrMetadataEXT): void {.stdcall.} | |
| 11633 proc loadVK_EXT_hdr_metadata*(instance: VkInstance) = | |
| 11634 loadVK_KHR_swapchain(instance) | |
| 11635 vkSetHdrMetadataEXT = cast[proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR, pMetadata: ptr VkHdrMetadataEXT): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetHdrMetadataEXT")) | |
| 11636 | |
| 11637 proc loadVK_KHR_present_id*(instance: VkInstance) = | |
| 11638 loadVK_KHR_swapchain(instance) | |
| 11639 loadVK_VERSION_1_1(instance) | |
| 11640 | |
| 11641 # extension VK_KHR_ray_tracing_maintenance1 | |
| 11642 var | |
| 11643 vkCmdTraceRaysIndirect2KHR*: proc(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.} | |
| 11644 proc loadVK_KHR_ray_tracing_maintenance1*(instance: VkInstance) = | |
| 11645 loadVK_KHR_acceleration_structure(instance) | |
| 11646 vkCmdTraceRaysIndirect2KHR = cast[proc(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdTraceRaysIndirect2KHR")) | |
| 11647 | |
| 11648 # extension VK_KHR_ray_tracing_pipeline | |
| 11649 var | |
| 11650 vkCmdTraceRaysKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, width: uint32, height: uint32, depth: uint32): void {.stdcall.} | |
| 11651 vkCreateRayTracingPipelinesKHR*: proc(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.} | |
| 11652 vkGetRayTracingShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.} | |
| 11653 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.} | |
| 11654 vkCmdTraceRaysIndirectKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.} | |
| 11655 vkGetRayTracingShaderGroupStackSizeKHR*: proc(device: VkDevice, pipeline: VkPipeline, group: uint32, groupShader: VkShaderGroupShaderKHR): VkDeviceSize {.stdcall.} | |
| 11656 vkCmdSetRayTracingPipelineStackSizeKHR*: proc(commandBuffer: VkCommandBuffer, pipelineStackSize: uint32): void {.stdcall.} | |
| 11657 proc loadVK_KHR_ray_tracing_pipeline*(instance: VkInstance) = | |
| 11658 loadVK_VERSION_1_2(instance) | |
| 11659 loadVK_KHR_acceleration_structure(instance) | |
| 11660 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")) | |
| 11661 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")) | |
| 11662 vkGetRayTracingShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesKHR")) | |
| 11663 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")) | |
| 11664 vkCmdTraceRaysIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: ptr VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdTraceRaysIndirectKHR")) | |
| 11665 vkGetRayTracingShaderGroupStackSizeKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, group: uint32, groupShader: VkShaderGroupShaderKHR): VkDeviceSize {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupStackSizeKHR")) | |
| 11666 vkCmdSetRayTracingPipelineStackSizeKHR = cast[proc(commandBuffer: VkCommandBuffer, pipelineStackSize: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdSetRayTracingPipelineStackSizeKHR")) | |
| 11667 | |
| 11668 # extension VK_HUAWEI_invocation_mask | |
| 11669 var | |
| 11670 vkCmdBindInvocationMaskHUAWEI*: proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.} | |
| 11671 proc loadVK_HUAWEI_invocation_mask*(instance: VkInstance) = | |
| 11672 loadVK_KHR_ray_tracing_pipeline(instance) | |
| 11673 loadVK_VERSION_1_3(instance) | |
| 11674 vkCmdBindInvocationMaskHUAWEI = cast[proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBindInvocationMaskHUAWEI")) | |
| 11675 | |
| 11676 # extension VK_EXT_display_surface_counter | |
| 11677 var | |
| 11678 vkGetPhysicalDeviceSurfaceCapabilities2EXT*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT): VkResult {.stdcall.} | |
| 11679 proc loadVK_EXT_display_surface_counter*(instance: VkInstance) = | |
| 11680 loadVK_KHR_display(instance) | |
| 11681 vkGetPhysicalDeviceSurfaceCapabilities2EXT = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) | |
| 11682 | |
| 11683 # extension VK_KHR_get_display_properties2 | |
| 11684 var | |
| 11685 vkGetPhysicalDeviceDisplayProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayProperties2KHR): VkResult {.stdcall.} | |
| 11686 vkGetPhysicalDeviceDisplayPlaneProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlaneProperties2KHR): VkResult {.stdcall.} | |
| 11687 vkGetDisplayModeProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModeProperties2KHR): VkResult {.stdcall.} | |
| 11688 vkGetDisplayPlaneCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR, pCapabilities: ptr VkDisplayPlaneCapabilities2KHR): VkResult {.stdcall.} | |
| 11689 proc loadVK_KHR_get_display_properties2*(instance: VkInstance) = | |
| 11690 loadVK_KHR_display(instance) | |
| 11691 vkGetPhysicalDeviceDisplayProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayProperties2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")) | |
| 11692 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayPlaneProperties2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) | |
| 11693 vkGetDisplayModeProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32, pProperties: ptr VkDisplayModeProperties2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayModeProperties2KHR")) | |
| 11694 vkGetDisplayPlaneCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR, pCapabilities: ptr VkDisplayPlaneCapabilities2KHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilities2KHR")) | |
| 11695 | |
| 11696 proc loadVK_KHR_ray_query*(instance: VkInstance) = | |
| 11697 loadVK_VERSION_1_2(instance) | |
| 11698 loadVK_KHR_acceleration_structure(instance) | |
| 11699 | |
| 11700 # extension VK_KHR_display_swapchain | |
| 11701 var | |
| 11702 vkCreateSharedSwapchainsKHR*: proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchains: ptr VkSwapchainKHR): VkResult {.stdcall.} | |
| 11703 proc loadVK_KHR_display_swapchain*(instance: VkInstance) = | |
| 11704 loadVK_KHR_swapchain(instance) | |
| 11705 loadVK_KHR_display(instance) | |
| 11706 vkCreateSharedSwapchainsKHR = cast[proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR, pAllocator: ptr VkAllocationCallbacks, pSwapchains: ptr VkSwapchainKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR")) | |
| 11707 | |
| 11708 # extension VK_EXT_acquire_drm_display | |
| 11709 var | |
| 11710 vkAcquireDrmDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, drmFd: int32, display: VkDisplayKHR): VkResult {.stdcall.} | |
| 11711 vkGetDrmDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, drmFd: int32, connectorId: uint32, display: ptr VkDisplayKHR): VkResult {.stdcall.} | |
| 11712 proc loadVK_EXT_acquire_drm_display*(instance: VkInstance) = | |
| 11713 loadVK_EXT_direct_mode_display(instance) | |
| 11714 vkAcquireDrmDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, drmFd: int32, display: VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT")) | |
| 11715 vkGetDrmDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, drmFd: int32, connectorId: uint32, display: ptr VkDisplayKHR): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT")) | |
| 11716 | |
| 11717 # extension VK_EXT_display_control | |
| 11718 var | |
| 11719 vkDisplayPowerControlEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT): VkResult {.stdcall.} | |
| 11720 vkRegisterDeviceEventEXT*: proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.} | |
| 11721 vkRegisterDisplayEventEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.} | |
| 11722 vkGetSwapchainCounterEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64): VkResult {.stdcall.} | |
| 11723 proc loadVK_EXT_display_control*(instance: VkInstance) = | |
| 11724 loadVK_EXT_display_surface_counter(instance) | |
| 11725 loadVK_KHR_swapchain(instance) | |
| 11726 vkDisplayPowerControlEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDisplayPowerControlEXT")) | |
| 11727 vkRegisterDeviceEventEXT = cast[proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkRegisterDeviceEventEXT")) | |
| 11728 vkRegisterDisplayEventEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT, pAllocator: ptr VkAllocationCallbacks, pFence: ptr VkFence): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkRegisterDisplayEventEXT")) | |
| 11729 vkGetSwapchainCounterEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetSwapchainCounterEXT")) | |
| 11730 | |
| 11731 proc loadVK_NV_ray_tracing_motion_blur*(instance: VkInstance) = | |
| 11732 loadVK_KHR_ray_tracing_pipeline(instance) | |
| 11733 | |
| 11734 proc loadVK_EXT_pipeline_library_group_handles*(instance: VkInstance) = | |
| 11735 loadVK_KHR_ray_tracing_pipeline(instance) | |
| 11736 loadVK_KHR_pipeline_library(instance) | |
| 11737 | |
| 11738 # extension VK_NV_ray_tracing | |
| 11739 var | |
| 11740 vkCreateAccelerationStructureNV*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureNV): VkResult {.stdcall.} | |
| 11741 vkDestroyAccelerationStructureNV*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.} | |
| 11742 vkGetAccelerationStructureMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2KHR): void {.stdcall.} | |
| 11743 vkBindAccelerationStructureMemoryNV*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoNV): VkResult {.stdcall.} | |
| 11744 vkCmdBuildAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.} | |
| 11745 vkCmdCopyAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.} | |
| 11746 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.} | |
| 11747 vkCreateRayTracingPipelinesNV*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.} | |
| 11748 vkGetRayTracingShaderGroupHandlesNV*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: csize_t, pData: pointer): VkResult {.stdcall.} | |
| 11749 vkGetAccelerationStructureHandleNV*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: csize_t, pData: pointer): VkResult {.stdcall.} | |
| 11750 vkCmdWriteAccelerationStructuresPropertiesNV*: proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.} | |
| 11751 vkCompileDeferredNV*: proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.} | |
| 11752 proc loadVK_NV_ray_tracing*(instance: VkInstance) = | |
| 11753 loadVK_VERSION_1_1(instance) | |
| 11754 loadVK_VERSION_1_1(instance) | |
| 11755 vkCreateAccelerationStructureNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pAccelerationStructure: ptr VkAccelerationStructureNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureNV")) | |
| 11756 vkDestroyAccelerationStructureNV = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: ptr VkAllocationCallbacks): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureNV")) | |
| 11757 vkGetAccelerationStructureMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: ptr VkMemoryRequirements2KHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureMemoryRequirementsNV")) | |
| 11758 vkBindAccelerationStructureMemoryNV = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoNV): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkBindAccelerationStructureMemoryNV")) | |
| 11759 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")) | |
| 11760 vkCmdCopyAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV")) | |
| 11761 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")) | |
| 11762 vkCreateRayTracingPipelinesNV = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV, pAllocator: ptr VkAllocationCallbacks, pPipelines: ptr VkPipeline): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV")) | |
| 11763 vkGetRayTracingShaderGroupHandlesNV = vkGetRayTracingShaderGroupHandlesKHR | |
| 11764 vkGetAccelerationStructureHandleNV = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: csize_t, pData: pointer): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureHandleNV")) | |
| 11765 vkCmdWriteAccelerationStructuresPropertiesNV = cast[proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesNV")) | |
| 11766 vkCompileDeferredNV = cast[proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCompileDeferredNV")) | |
| 11767 | |
| 11768 # extension VK_KHR_present_wait | |
| 11769 var | |
| 11770 vkWaitForPresentKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, presentId: uint64, timeout: uint64): VkResult {.stdcall.} | |
| 11771 proc loadVK_KHR_present_wait*(instance: VkInstance) = | |
| 11772 loadVK_KHR_swapchain(instance) | |
| 11773 loadVK_KHR_present_id(instance) | |
| 11774 vkWaitForPresentKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, presentId: uint64, timeout: uint64): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkWaitForPresentKHR")) | |
| 11775 | |
| 11776 proc loadVK_NV_ray_tracing_invocation_reorder*(instance: VkInstance) = | |
| 11777 loadVK_KHR_ray_tracing_pipeline(instance) | |
| 11778 | |
| 11779 var EXTENSION_LOADERS = { | |
| 11780 "VK_NV_optical_flow": loadVK_NV_optical_flow, | |
| 11781 "VK_EXT_vertex_attribute_divisor": loadVK_EXT_vertex_attribute_divisor, | |
| 11782 "VK_EXT_pipeline_library_group_handles": loadVK_EXT_pipeline_library_group_handles, | |
| 11783 "VK_NV_geometry_shader_passthrough": loadVK_NV_geometry_shader_passthrough, | |
| 11784 "VK_EXT_line_rasterization": loadVK_EXT_line_rasterization, | |
| 11785 "VK_EXT_rasterization_order_attachment_access": loadVK_EXT_rasterization_order_attachment_access, | |
| 11786 "VK_EXT_shader_atomic_float2": loadVK_EXT_shader_atomic_float2, | |
| 11787 "VK_IMG_format_pvrtc": loadVK_IMG_format_pvrtc, | |
| 11788 "VK_AMD_texture_gather_bias_lod": loadVK_AMD_texture_gather_bias_lod, | |
| 11789 "VK_KHR_shader_subgroup_uniform_control_flow": loadVK_KHR_shader_subgroup_uniform_control_flow, | |
| 11790 "VK_AMD_shader_fragment_mask": loadVK_AMD_shader_fragment_mask, | |
| 11791 "VK_EXT_external_memory_dma_buf": loadVK_EXT_external_memory_dma_buf, | |
| 11792 "VK_IMG_filter_cubic": loadVK_IMG_filter_cubic, | |
| 11793 "VK_EXT_pageable_device_local_memory": loadVK_EXT_pageable_device_local_memory, | |
| 11794 "VK_EXT_primitive_topology_list_restart": loadVK_EXT_primitive_topology_list_restart, | |
| 11795 "VK_KHR_global_priority": loadVK_KHR_global_priority, | |
| 11796 "VK_AMD_shader_ballot": loadVK_AMD_shader_ballot, | |
| 11797 "VK_AMD_buffer_marker": loadVK_AMD_buffer_marker, | |
| 11798 "VK_NV_corner_sampled_image": loadVK_NV_corner_sampled_image, | |
| 11799 "VK_NV_ray_tracing_invocation_reorder": loadVK_NV_ray_tracing_invocation_reorder, | |
| 11800 "VK_QCOM_image_processing": loadVK_QCOM_image_processing, | |
| 11801 "VK_AMD_shader_info": loadVK_AMD_shader_info, | |
| 11802 "VK_KHR_pipeline_library": loadVK_KHR_pipeline_library, | |
| 11803 "VK_EXT_blend_operation_advanced": loadVK_EXT_blend_operation_advanced, | |
| 11804 "VK_AMD_gpu_shader_int16": loadVK_AMD_gpu_shader_int16, | |
| 11805 "VK_EXT_pipeline_robustness": loadVK_EXT_pipeline_robustness, | |
| 11806 "VK_NV_scissor_exclusive": loadVK_NV_scissor_exclusive, | |
| 11807 "VK_EXT_sample_locations": loadVK_EXT_sample_locations, | |
| 11808 "VK_NV_framebuffer_mixed_samples": loadVK_NV_framebuffer_mixed_samples, | |
| 11809 "VK_NV_sample_mask_override_coverage": loadVK_NV_sample_mask_override_coverage, | |
| 11810 "VK_KHR_present_id": loadVK_KHR_present_id, | |
| 11811 "VK_EXT_descriptor_buffer": loadVK_EXT_descriptor_buffer, | |
| 11812 "VK_EXT_filter_cubic": loadVK_EXT_filter_cubic, | |
| 11813 "VK_KHR_pipeline_executable_properties": loadVK_KHR_pipeline_executable_properties, | |
| 11814 "VK_EXT_extended_dynamic_state3": loadVK_EXT_extended_dynamic_state3, | |
| 11815 "VK_KHR_performance_query": loadVK_KHR_performance_query, | |
| 11816 "VK_GOOGLE_user_type": loadVK_GOOGLE_user_type, | |
| 11817 "VK_KHR_ray_tracing_maintenance1": loadVK_KHR_ray_tracing_maintenance1, | |
| 11818 "VK_EXT_debug_report": loadVK_EXT_debug_report, | |
| 11819 "VK_EXT_multisampled_render_to_single_sampled": loadVK_EXT_multisampled_render_to_single_sampled, | |
| 11820 "VK_EXT_device_address_binding_report": loadVK_EXT_device_address_binding_report, | |
| 11821 "VK_NV_clip_space_w_scaling": loadVK_NV_clip_space_w_scaling, | |
| 11822 "VK_NV_fill_rectangle": loadVK_NV_fill_rectangle, | |
| 11823 "VK_EXT_shader_image_atomic_int64": loadVK_EXT_shader_image_atomic_int64, | |
| 11824 "VK_KHR_swapchain": loadVK_KHR_swapchain, | |
| 11825 "VK_NV_ray_tracing": loadVK_NV_ray_tracing, | |
| 11826 "VK_EXT_swapchain_maintenance1": loadVK_EXT_swapchain_maintenance1, | |
| 11827 "VK_KHR_ray_tracing_pipeline": loadVK_KHR_ray_tracing_pipeline, | |
| 11828 "VK_EXT_ycbcr_image_arrays": loadVK_EXT_ycbcr_image_arrays, | |
| 11829 "VK_AMD_negative_viewport_height": loadVK_AMD_negative_viewport_height, | |
| 11830 "VK_EXT_provoking_vertex": loadVK_EXT_provoking_vertex, | |
| 11831 "VK_EXT_calibrated_timestamps": loadVK_EXT_calibrated_timestamps, | |
| 11832 "VK_EXT_attachment_feedback_loop_layout": loadVK_EXT_attachment_feedback_loop_layout, | |
| 11833 "VK_AMD_mixed_attachment_samples": loadVK_AMD_mixed_attachment_samples, | |
| 11834 "VK_HUAWEI_invocation_mask": loadVK_HUAWEI_invocation_mask, | |
| 11835 "VK_EXT_external_memory_host": loadVK_EXT_external_memory_host, | |
| 11836 "VK_NV_device_diagnostics_config": loadVK_NV_device_diagnostics_config, | |
| 11837 "VK_EXT_fragment_density_map2": loadVK_EXT_fragment_density_map2, | |
| 11838 "VK_NV_shader_subgroup_partitioned": loadVK_NV_shader_subgroup_partitioned, | |
| 11839 "VK_EXT_image_sliced_view_of_3d": loadVK_EXT_image_sliced_view_of_3d, | |
| 11840 "VK_NV_fragment_shading_rate_enums": loadVK_NV_fragment_shading_rate_enums, | |
| 11841 "VK_EXT_display_surface_counter": loadVK_EXT_display_surface_counter, | |
| 11842 "VK_ARM_shader_core_properties": loadVK_ARM_shader_core_properties, | |
| 11843 "VK_EXT_shader_module_identifier": loadVK_EXT_shader_module_identifier, | |
| 11844 "VK_EXT_border_color_swizzle": loadVK_EXT_border_color_swizzle, | |
| 11845 "VK_AMD_shader_image_load_store_lod": loadVK_AMD_shader_image_load_store_lod, | |
| 11846 "VK_AMD_display_native_hdr": loadVK_AMD_display_native_hdr, | |
| 11847 "VK_NV_memory_decompression": loadVK_NV_memory_decompression, | |
| 11848 "VK_EXT_direct_mode_display": loadVK_EXT_direct_mode_display, | |
| 11849 "VK_EXT_fragment_shader_interlock": loadVK_EXT_fragment_shader_interlock, | |
| 11850 "VK_NV_coverage_reduction_mode": loadVK_NV_coverage_reduction_mode, | |
| 11851 "VK_KHR_get_display_properties2": loadVK_KHR_get_display_properties2, | |
| 11852 "VK_INTEL_shader_integer_functions2": loadVK_INTEL_shader_integer_functions2, | |
| 11853 "VK_NV_glsl_shader": loadVK_NV_glsl_shader, | |
| 11854 "VK_KHR_shader_clock": loadVK_KHR_shader_clock, | |
| 11855 "VK_EXT_image_2d_view_of_3d": loadVK_EXT_image_2d_view_of_3d, | |
| 11856 "VK_QCOM_tile_properties": loadVK_QCOM_tile_properties, | |
| 11857 "VK_KHR_push_descriptor": loadVK_KHR_push_descriptor, | |
| 11858 "VK_NV_viewport_swizzle": loadVK_NV_viewport_swizzle, | |
| 11859 "VK_KHR_ray_query": loadVK_KHR_ray_query, | |
| 11860 "VK_KHR_present_wait": loadVK_KHR_present_wait, | |
| 11861 "VK_NV_shading_rate_image": loadVK_NV_shading_rate_image, | |
| 11862 "VK_EXT_fragment_density_map": loadVK_EXT_fragment_density_map, | |
| 11863 "VK_NV_device_diagnostic_checkpoints": loadVK_NV_device_diagnostic_checkpoints, | |
| 11864 "VK_EXT_pci_bus_info": loadVK_EXT_pci_bus_info, | |
| 11865 "VK_NV_external_memory": loadVK_NV_external_memory, | |
| 11866 "VK_EXT_queue_family_foreign": loadVK_EXT_queue_family_foreign, | |
| 11867 "VK_KHR_swapchain_mutable_format": loadVK_KHR_swapchain_mutable_format, | |
| 11868 "VK_EXT_depth_clip_control": loadVK_EXT_depth_clip_control, | |
| 11869 "VK_EXT_debug_utils": loadVK_EXT_debug_utils, | |
| 11870 "VK_KHR_portability_enumeration": loadVK_KHR_portability_enumeration, | |
| 11871 "VK_EXT_memory_priority": loadVK_EXT_memory_priority, | |
| 11872 "VK_EXT_validation_flags": loadVK_EXT_validation_flags, | |
| 11873 "VK_AMD_shader_core_properties": loadVK_AMD_shader_core_properties, | |
| 11874 "VK_EXT_conservative_rasterization": loadVK_EXT_conservative_rasterization, | |
| 11875 "VK_KHR_external_fence_fd": loadVK_KHR_external_fence_fd, | |
| 11876 "VK_NV_device_generated_commands": loadVK_NV_device_generated_commands, | |
| 11877 "VK_NV_present_barrier": loadVK_NV_present_barrier, | |
| 11878 "VK_AMD_gcn_shader": loadVK_AMD_gcn_shader, | |
| 11879 "VK_NV_viewport_array2": loadVK_NV_viewport_array2, | |
| 11880 "VK_INTEL_performance_query": loadVK_INTEL_performance_query, | |
| 11881 "VK_NVX_multiview_per_view_attributes": loadVK_NVX_multiview_per_view_attributes, | |
| 11882 "VK_EXT_primitives_generated_query": loadVK_EXT_primitives_generated_query, | |
| 11883 "VK_AMD_pipeline_compiler_control": loadVK_AMD_pipeline_compiler_control, | |
| 11884 "VK_EXT_post_depth_coverage": loadVK_EXT_post_depth_coverage, | |
| 11885 "VK_EXT_rgba10x6_formats": loadVK_EXT_rgba10x6_formats, | |
| 11886 "VK_KHR_external_memory_fd": loadVK_KHR_external_memory_fd, | |
| 11887 "VK_NV_dedicated_allocation_image_aliasing": loadVK_NV_dedicated_allocation_image_aliasing, | |
| 11888 "VK_NV_cooperative_matrix": loadVK_NV_cooperative_matrix, | |
| 11889 "VK_EXT_depth_clamp_zero_one": loadVK_EXT_depth_clamp_zero_one, | |
| 11890 "VK_EXT_conditional_rendering": loadVK_EXT_conditional_rendering, | |
| 11891 "VK_QCOM_multiview_per_view_viewports": loadVK_QCOM_multiview_per_view_viewports, | |
| 11892 "VK_NV_linear_color_attachment": loadVK_NV_linear_color_attachment, | |
| 11893 "VK_EXT_shader_subgroup_ballot": loadVK_EXT_shader_subgroup_ballot, | |
| 11894 "VK_EXT_multi_draw": loadVK_EXT_multi_draw, | |
| 11895 "VK_NV_fragment_coverage_to_color": loadVK_NV_fragment_coverage_to_color, | |
| 11896 "VK_EXT_load_store_op_none": loadVK_EXT_load_store_op_none, | |
| 11897 "VK_QCOM_rotated_copy_commands": loadVK_QCOM_rotated_copy_commands, | |
| 11898 "VK_EXT_surface_maintenance1": loadVK_EXT_surface_maintenance1, | |
| 11899 "VK_EXT_swapchain_colorspace": loadVK_EXT_swapchain_colorspace, | |
| 11900 "VK_EXT_image_drm_format_modifier": loadVK_EXT_image_drm_format_modifier, | |
| 11901 "VK_EXT_validation_features": loadVK_EXT_validation_features, | |
| 11902 "VK_KHR_workgroup_memory_explicit_layout": loadVK_KHR_workgroup_memory_explicit_layout, | |
| 11903 "VK_EXT_index_type_uint8": loadVK_EXT_index_type_uint8, | |
| 11904 "VK_EXT_mesh_shader": loadVK_EXT_mesh_shader, | |
| 11905 "VK_AMD_shader_early_and_late_fragment_tests": loadVK_AMD_shader_early_and_late_fragment_tests, | |
| 11906 "VK_KHR_display_swapchain": loadVK_KHR_display_swapchain, | |
| 11907 "VK_EXT_transform_feedback": loadVK_EXT_transform_feedback, | |
| 11908 "VK_GOOGLE_decorate_string": loadVK_GOOGLE_decorate_string, | |
| 11909 "VK_EXT_shader_atomic_float": loadVK_EXT_shader_atomic_float, | |
| 11910 "VK_EXT_acquire_drm_display": loadVK_EXT_acquire_drm_display, | |
| 11911 "VK_EXT_pipeline_properties": loadVK_EXT_pipeline_properties, | |
| 11912 "VK_EXT_graphics_pipeline_library": loadVK_EXT_graphics_pipeline_library, | |
| 11913 "VK_KHR_acceleration_structure": loadVK_KHR_acceleration_structure, | |
| 11914 "VK_AMD_shader_core_properties2": loadVK_AMD_shader_core_properties2, | |
| 11915 "VK_KHR_surface": loadVK_KHR_surface, | |
| 11916 "VK_AMD_gpu_shader_half_float": loadVK_AMD_gpu_shader_half_float, | |
| 11917 "VK_KHR_deferred_host_operations": loadVK_KHR_deferred_host_operations, | |
| 11918 "VK_NV_dedicated_allocation": loadVK_NV_dedicated_allocation, | |
| 11919 "VK_GOOGLE_hlsl_functionality1": loadVK_GOOGLE_hlsl_functionality1, | |
| 11920 "VK_EXT_robustness2": loadVK_EXT_robustness2, | |
| 11921 "VK_NVX_image_view_handle": loadVK_NVX_image_view_handle, | |
| 11922 "VK_EXT_non_seamless_cube_map": loadVK_EXT_non_seamless_cube_map, | |
| 11923 "VK_EXT_opacity_micromap": loadVK_EXT_opacity_micromap, | |
| 11924 "VK_EXT_image_view_min_lod": loadVK_EXT_image_view_min_lod, | |
| 11925 "VK_AMD_shader_trinary_minmax": loadVK_AMD_shader_trinary_minmax, | |
| 11926 "VK_QCOM_render_pass_store_ops": loadVK_QCOM_render_pass_store_ops, | |
| 11927 "VK_EXT_device_fault": loadVK_EXT_device_fault, | |
| 11928 "VK_EXT_custom_border_color": loadVK_EXT_custom_border_color, | |
| 11929 "VK_EXT_mutable_descriptor_type": loadVK_EXT_mutable_descriptor_type, | |
| 11930 "VK_AMD_rasterization_order": loadVK_AMD_rasterization_order, | |
| 11931 "VK_EXT_vertex_input_dynamic_state": loadVK_EXT_vertex_input_dynamic_state, | |
| 11932 "VK_KHR_incremental_present": loadVK_KHR_incremental_present, | |
| 11933 "VK_KHR_fragment_shading_rate": loadVK_KHR_fragment_shading_rate, | |
| 11934 "VK_EXT_color_write_enable": loadVK_EXT_color_write_enable, | |
| 11935 "VK_SEC_amigo_profiling": loadVK_SEC_amigo_profiling, | |
| 11936 "VK_GOOGLE_display_timing": loadVK_GOOGLE_display_timing, | |
| 11937 "VK_NVX_binary_import": loadVK_NVX_binary_import, | |
| 11938 "VK_EXT_depth_clip_enable": loadVK_EXT_depth_clip_enable, | |
| 11939 "VK_EXT_subpass_merge_feedback": loadVK_EXT_subpass_merge_feedback, | |
| 11940 "VK_NV_representative_fragment_test": loadVK_NV_representative_fragment_test, | |
| 11941 "VK_EXT_validation_cache": loadVK_EXT_validation_cache, | |
| 11942 "VK_EXT_display_control": loadVK_EXT_display_control, | |
| 11943 "VK_KHR_external_semaphore_fd": loadVK_KHR_external_semaphore_fd, | |
| 11944 "VK_KHR_fragment_shader_barycentric": loadVK_KHR_fragment_shader_barycentric, | |
| 11945 "VK_NV_inherited_viewport_scissor": loadVK_NV_inherited_viewport_scissor, | |
| 11946 "VK_EXT_legacy_dithering": loadVK_EXT_legacy_dithering, | |
| 11947 "VK_NV_ray_tracing_motion_blur": loadVK_NV_ray_tracing_motion_blur, | |
| 11948 "VK_EXT_physical_device_drm": loadVK_EXT_physical_device_drm, | |
| 11949 "VK_EXT_pipeline_protected_access": loadVK_EXT_pipeline_protected_access, | |
| 11950 "VK_QCOM_render_pass_transform": loadVK_QCOM_render_pass_transform, | |
| 11951 "VK_GOOGLE_surfaceless_query": loadVK_GOOGLE_surfaceless_query, | |
| 11952 "VK_EXT_memory_budget": loadVK_EXT_memory_budget, | |
| 11953 "VK_EXT_discard_rectangles": loadVK_EXT_discard_rectangles, | |
| 11954 "VK_EXT_shader_stencil_export": loadVK_EXT_shader_stencil_export, | |
| 11955 "VK_KHR_shared_presentable_image": loadVK_KHR_shared_presentable_image, | |
| 11956 "VK_NV_external_memory_rdma": loadVK_NV_external_memory_rdma, | |
| 11957 "VK_EXT_image_compression_control_swapchain": loadVK_EXT_image_compression_control_swapchain, | |
| 11958 "VK_EXT_hdr_metadata": loadVK_EXT_hdr_metadata, | |
| 11959 "VK_AMD_device_coherent_memory": loadVK_AMD_device_coherent_memory, | |
| 11960 "VK_EXT_device_memory_report": loadVK_EXT_device_memory_report, | |
| 11961 "VK_ARM_shader_core_builtins": loadVK_ARM_shader_core_builtins, | |
| 11962 "VK_QCOM_multiview_per_view_render_areas": loadVK_QCOM_multiview_per_view_render_areas, | |
| 11963 "VK_LUNARG_direct_driver_loading": loadVK_LUNARG_direct_driver_loading, | |
| 11964 "VK_AMD_memory_overallocation_behavior": loadVK_AMD_memory_overallocation_behavior, | |
| 11965 "VK_NV_mesh_shader": loadVK_NV_mesh_shader, | |
| 11966 "VK_AMD_shader_explicit_vertex_parameter": loadVK_AMD_shader_explicit_vertex_parameter, | |
| 11967 "VK_EXT_headless_surface": loadVK_EXT_headless_surface, | |
| 11968 "VK_NV_shader_sm_builtins": loadVK_NV_shader_sm_builtins, | |
| 11969 "VK_EXT_shader_subgroup_vote": loadVK_EXT_shader_subgroup_vote, | |
| 11970 "VK_NV_copy_memory_indirect": loadVK_NV_copy_memory_indirect, | |
| 11971 "VK_EXT_image_compression_control": loadVK_EXT_image_compression_control, | |
| 11972 "VK_EXT_astc_decode_mode": loadVK_EXT_astc_decode_mode, | |
| 11973 "VK_EXT_buffer_device_address": loadVK_EXT_buffer_device_address, | |
| 11974 "VK_KHR_get_surface_capabilities2": loadVK_KHR_get_surface_capabilities2, | |
| 11975 "VK_KHR_display": loadVK_KHR_display, | |
| 11976 "VK_QCOM_render_pass_shader_resolve": loadVK_QCOM_render_pass_shader_resolve, | |
| 11977 "VK_EXT_depth_range_unrestricted": loadVK_EXT_depth_range_unrestricted, | |
| 11978 "VK_HUAWEI_subpass_shading": loadVK_HUAWEI_subpass_shading, | |
| 11979 "VK_VALVE_descriptor_set_host_mapping": loadVK_VALVE_descriptor_set_host_mapping, | |
| 11980 "VK_HUAWEI_cluster_culling_shader": loadVK_HUAWEI_cluster_culling_shader, | |
| 11981 "VK_KHR_surface_protected_capabilities": loadVK_KHR_surface_protected_capabilities, | |
| 11982 "VK_NV_shader_image_footprint": loadVK_NV_shader_image_footprint, | |
| 11983 "VK_NV_external_memory_capabilities": loadVK_NV_external_memory_capabilities, | |
| 11984 "VK_NV_compute_shader_derivatives": loadVK_NV_compute_shader_derivatives, | |
| 11985 "VK_QCOM_fragment_density_map_offset": loadVK_QCOM_fragment_density_map_offset, | |
| 11986 }.toTable | |
| 11987 when defined(VK_USE_PLATFORM_XLIB_KHR): | |
| 11988 include ../vulkan/platform/xlib | |
| 11989 EXTENSION_LOADERS["VK_KHR_xlib_surface"] = loadVK_KHR_xlib_surface | |
| 11990 when defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT): | |
| 11991 include ../vulkan/platform/xlib_xrandr | |
| 11992 EXTENSION_LOADERS["VK_EXT_acquire_xlib_display"] = loadVK_EXT_acquire_xlib_display | |
| 11993 when defined(VK_USE_PLATFORM_XCB_KHR): | |
| 11994 include ../vulkan/platform/xcb | |
| 11995 EXTENSION_LOADERS["VK_KHR_xcb_surface"] = loadVK_KHR_xcb_surface | |
| 11996 when defined(VK_USE_PLATFORM_WAYLAND_KHR): | |
| 11997 include ../vulkan/platform/wayland | |
| 11998 EXTENSION_LOADERS["VK_KHR_wayland_surface"] = loadVK_KHR_wayland_surface | |
| 11999 when defined(VK_USE_PLATFORM_DIRECTFB_EXT): | |
| 12000 include ../vulkan/platform/directfb | |
| 12001 EXTENSION_LOADERS["VK_EXT_directfb_surface"] = loadVK_EXT_directfb_surface | |
| 12002 when defined(VK_USE_PLATFORM_ANDROID_KHR): | |
| 12003 include ../vulkan/platform/android | |
| 12004 EXTENSION_LOADERS["VK_KHR_android_surface"] = loadVK_KHR_android_surface | |
| 12005 EXTENSION_LOADERS["VK_ANDROID_external_memory_android_hardware_buffer"] = loadVK_ANDROID_external_memory_android_hardware_buffer | |
| 12006 when defined(VK_USE_PLATFORM_WIN32_KHR): | |
| 12007 include ../vulkan/platform/win32 | |
| 12008 EXTENSION_LOADERS["VK_KHR_external_semaphore_win32"] = loadVK_KHR_external_semaphore_win32 | |
| 12009 EXTENSION_LOADERS["VK_EXT_full_screen_exclusive"] = loadVK_EXT_full_screen_exclusive | |
| 12010 EXTENSION_LOADERS["VK_NV_external_memory_win32"] = loadVK_NV_external_memory_win32 | |
| 12011 EXTENSION_LOADERS["VK_KHR_external_memory_win32"] = loadVK_KHR_external_memory_win32 | |
| 12012 EXTENSION_LOADERS["VK_NV_acquire_winrt_display"] = loadVK_NV_acquire_winrt_display | |
| 12013 EXTENSION_LOADERS["VK_KHR_win32_surface"] = loadVK_KHR_win32_surface | |
| 12014 EXTENSION_LOADERS["VK_KHR_external_fence_win32"] = loadVK_KHR_external_fence_win32 | |
| 12015 EXTENSION_LOADERS["VK_KHR_win32_keyed_mutex"] = loadVK_KHR_win32_keyed_mutex | |
| 12016 when defined(VK_USE_PLATFORM_VI_NN): | |
| 12017 include ../vulkan/platform/vi | |
| 12018 EXTENSION_LOADERS["VK_NN_vi_surface"] = loadVK_NN_vi_surface | |
| 12019 when defined(VK_USE_PLATFORM_IOS_MVK): | |
| 12020 include ../vulkan/platform/ios | |
| 12021 EXTENSION_LOADERS["VK_MVK_ios_surface"] = loadVK_MVK_ios_surface | |
| 12022 when defined(VK_USE_PLATFORM_MACOS_MVK): | |
| 12023 include ../vulkan/platform/macos | |
| 12024 EXTENSION_LOADERS["VK_MVK_macos_surface"] = loadVK_MVK_macos_surface | |
| 12025 when defined(VK_USE_PLATFORM_METAL_EXT): | |
| 12026 include ../vulkan/platform/metal | |
| 12027 EXTENSION_LOADERS["VK_EXT_metal_objects"] = loadVK_EXT_metal_objects | |
| 12028 EXTENSION_LOADERS["VK_EXT_metal_surface"] = loadVK_EXT_metal_surface | |
| 12029 when defined(VK_USE_PLATFORM_FUCHSIA): | |
| 12030 include ../vulkan/platform/fuchsia | |
| 12031 EXTENSION_LOADERS["VK_FUCHSIA_external_semaphore"] = loadVK_FUCHSIA_external_semaphore | |
| 12032 EXTENSION_LOADERS["VK_FUCHSIA_imagepipe_surface"] = loadVK_FUCHSIA_imagepipe_surface | |
| 12033 EXTENSION_LOADERS["VK_FUCHSIA_external_memory"] = loadVK_FUCHSIA_external_memory | |
| 12034 EXTENSION_LOADERS["VK_FUCHSIA_buffer_collection"] = loadVK_FUCHSIA_buffer_collection | |
| 12035 when defined(VK_USE_PLATFORM_GGP): | |
| 12036 include ../vulkan/platform/ggp | |
| 12037 EXTENSION_LOADERS["VK_GGP_frame_token"] = loadVK_GGP_frame_token | |
| 12038 EXTENSION_LOADERS["VK_GGP_stream_descriptor_surface"] = loadVK_GGP_stream_descriptor_surface | |
| 12039 when defined(VK_USE_PLATFORM_SCI): | |
| 12040 include ../vulkan/platform/sci | |
| 12041 when defined(VK_ENABLE_BETA_EXTENSIONS): | |
| 12042 include ../vulkan/platform/provisional | |
| 12043 EXTENSION_LOADERS["VK_KHR_video_encode_queue"] = loadVK_KHR_video_encode_queue | |
| 12044 EXTENSION_LOADERS["VK_KHR_video_queue"] = loadVK_KHR_video_queue | |
| 12045 EXTENSION_LOADERS["VK_EXT_video_encode_h264"] = loadVK_EXT_video_encode_h264 | |
| 12046 EXTENSION_LOADERS["VK_EXT_video_encode_h265"] = loadVK_EXT_video_encode_h265 | |
| 12047 EXTENSION_LOADERS["VK_KHR_video_decode_queue"] = loadVK_KHR_video_decode_queue | |
| 12048 EXTENSION_LOADERS["VK_KHR_video_decode_h264"] = loadVK_KHR_video_decode_h264 | |
| 12049 EXTENSION_LOADERS["VK_KHR_portability_subset"] = loadVK_KHR_portability_subset | |
| 12050 EXTENSION_LOADERS["VK_KHR_video_decode_h265"] = loadVK_KHR_video_decode_h265 | |
| 12051 when defined(VK_USE_PLATFORM_SCREEN_QNX): | |
| 12052 include ../vulkan/platform/screen | |
| 12053 EXTENSION_LOADERS["VK_QNX_screen_surface"] = loadVK_QNX_screen_surface | |
| 12054 | |
| 12055 proc loadExtension*(instance: VkInstance, extension: string) = | |
| 12056 if extension in EXTENSION_LOADERS: | |
| 12057 EXTENSION_LOADERS[extension](instance) | |
| 12058 | |
| 12059 # load global functions immediately | |
| 12060 block globalFunctions: | |
| 12061 let instance = VkInstance(0) | |
| 12062 vkEnumerateInstanceVersion = cast[proc(pApiVersion: ptr uint32): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceVersion")) | |
| 12063 vkEnumerateInstanceExtensionProperties = cast[proc(pLayerName: cstring, pPropertyCount: ptr uint32, pProperties: ptr VkExtensionProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceExtensionProperties")) | |
| 12064 vkEnumerateInstanceLayerProperties = cast[proc(pPropertyCount: ptr uint32, pProperties: ptr VkLayerProperties): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkEnumerateInstanceLayerProperties")) | |
| 12065 vkCreateInstance = cast[proc(pCreateInfo: ptr VkInstanceCreateInfo, pAllocator: ptr VkAllocationCallbacks, pInstance: ptr VkInstance): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateInstance")) | |
| 12066 | |
| 12067 converter NimBool2VkBool*(a: bool): VkBool32 = VkBool32(a) |