1 /* 2 ** Copyright (c) 2015-2016 The Khronos Group Inc. 3 ** 4 ** Permission is hereby granted, free of charge, to any person obtaining a 5 ** copy of this software and/or associated documentation files (the 6 ** "Materials"), to deal in the Materials without restriction, including 7 ** without limitation the rights to use, copy, modify, merge, publish, 8 ** distribute, sublicense, and/or sell copies of the Materials, and to 9 ** permit persons to whom the Materials are furnished to do so, subject to 10 ** the following conditions: 11 ** 12 ** The above copyright notice and this permission notice shall be included 13 ** in all copies or substantial portions of the Materials. 14 ** 15 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 18 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 19 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 20 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 21 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. 22 */ 23 module derelict.vulkan.vk; 24 25 enum VK_VERSION_1_0 = 1; 26 //#include "vk_platform.h" 27 28 auto VK_MAKE_VERSION(int major, int minor, int patch) { 29 return (major << 22) | (minor << 12) | patch; 30 } 31 32 // Vulkan API version supported by this file 33 enum VK_API_VERSION = VK_MAKE_VERSION(1, 0, 3); 34 35 auto VK_VERSION_MAJOR(uint ver) { 36 return ver >> 22; 37 } 38 39 auto VK_VERSION_MINOR(uint ver) { 40 return (ver >> 12) & 0x3ff; 41 } 42 43 auto VK_VERSION_PATCH(uint ver) { 44 return ver & 0xfff; 45 } 46 47 enum VK_NULL_HANDLE = 0; 48 49 private auto VK_DEFINE_HANDLE(string name) { 50 return "struct " ~ name ~ "_T; \n alias " ~ name ~ " = " ~ name ~ "_T*;"; 51 } 52 53 private auto VK_DEFINE_NON_DISPATCHABLE_HANDLE(string name) { 54 // #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) 55 return "struct " ~ name ~ "_T; \n alias " ~ name ~ " = " ~ name ~ "_T*;"; 56 } 57 58 alias VkFlags = uint; 59 alias VkBool32 = uint; 60 alias VkDeviceSize = ulong; 61 alias VkSampleMask = uint; 62 63 mixin(VK_DEFINE_HANDLE("VkInstance")); 64 mixin(VK_DEFINE_HANDLE("VkPhysicalDevice")); 65 mixin(VK_DEFINE_HANDLE("VkDevice")); 66 mixin(VK_DEFINE_HANDLE("VkQueue")); 67 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkSemaphore")); 68 mixin(VK_DEFINE_HANDLE("VkCommandBuffer")); 69 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkFence")); 70 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDeviceMemory")); 71 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkBuffer")); 72 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkImage")); 73 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkEvent")); 74 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkQueryPool")); 75 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkBufferView")); 76 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkImageView")); 77 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkShaderModule")); 78 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkPipelineCache")); 79 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkPipelineLayout")); 80 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkRenderPass")); 81 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkPipeline")); 82 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDescriptorSetLayout")); 83 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkSampler")); 84 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDescriptorPool")); 85 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDescriptorSet")); 86 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkFramebuffer")); 87 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkCommandPool")); 88 89 enum VK_LOD_CLAMP_NONE = 1000.0f; 90 enum VK_REMAINING_MIP_LEVELS = (~0U); 91 enum VK_REMAINING_ARRAY_LAYERS = (~0U); 92 enum VK_WHOLE_SIZE = (~0UL); 93 enum VK_ATTACHMENT_UNUSED = (~0U); 94 enum VK_TRUE = 1; 95 enum VK_FALSE = 0; 96 enum VK_QUEUE_FAMILY_IGNORED = (~0U); 97 enum VK_SUBPASS_EXTERNAL = (~0U); 98 enum VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; 99 enum VK_UUID_SIZE = 16; 100 enum VK_MAX_MEMORY_TYPES = 32; 101 enum VK_MAX_MEMORY_HEAPS = 16; 102 enum VK_MAX_EXTENSION_NAME_SIZE = 256; 103 enum VK_MAX_DESCRIPTION_SIZE = 256; 104 105 enum VkPipelineCacheHeaderVersion { 106 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 107 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 108 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 109 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), 110 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF 111 } 112 113 enum VkResult { 114 VK_SUCCESS = 0, 115 VK_NOT_READY = 1, 116 VK_TIMEOUT = 2, 117 VK_EVENT_SET = 3, 118 VK_EVENT_RESET = 4, 119 VK_INCOMPLETE = 5, 120 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 121 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 122 VK_ERROR_INITIALIZATION_FAILED = -3, 123 VK_ERROR_DEVICE_LOST = -4, 124 VK_ERROR_MEMORY_MAP_FAILED = -5, 125 VK_ERROR_LAYER_NOT_PRESENT = -6, 126 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 127 VK_ERROR_FEATURE_NOT_PRESENT = -8, 128 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 129 VK_ERROR_TOO_MANY_OBJECTS = -10, 130 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 131 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 132 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 133 VK_SUBOPTIMAL_KHR = 1000001003, 134 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 135 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 136 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, 137 VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED, 138 VK_RESULT_END_RANGE = VK_INCOMPLETE, 139 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1), 140 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 141 } 142 143 enum VkStructureType { 144 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 145 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 146 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 147 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 148 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 149 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 150 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 151 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 152 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 153 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 154 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 155 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 156 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 157 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 158 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 159 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 160 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 161 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 162 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 163 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 164 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 165 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 166 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 167 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 168 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 169 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 170 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 171 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 172 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 173 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 174 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 175 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 176 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 177 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 178 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 179 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 180 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 181 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 182 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 183 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 184 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 185 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 186 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 187 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 188 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 189 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 190 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 191 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 192 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 193 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 194 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 195 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 196 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 197 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 198 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 199 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 200 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 201 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 202 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 203 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 204 VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, 205 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 206 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 207 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), 208 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 209 } 210 211 enum VkSystemAllocationScope { 212 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 213 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 214 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 215 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 216 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 217 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 218 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 219 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), 220 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 221 } 222 223 enum VkInternalAllocationType { 224 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 225 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 226 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 227 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), 228 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 229 } 230 231 enum VkFormat { 232 VK_FORMAT_UNDEFINED = 0, 233 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 234 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 235 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 236 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 237 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 238 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 239 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 240 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 241 VK_FORMAT_R8_UNORM = 9, 242 VK_FORMAT_R8_SNORM = 10, 243 VK_FORMAT_R8_USCALED = 11, 244 VK_FORMAT_R8_SSCALED = 12, 245 VK_FORMAT_R8_UINT = 13, 246 VK_FORMAT_R8_SINT = 14, 247 VK_FORMAT_R8_SRGB = 15, 248 VK_FORMAT_R8G8_UNORM = 16, 249 VK_FORMAT_R8G8_SNORM = 17, 250 VK_FORMAT_R8G8_USCALED = 18, 251 VK_FORMAT_R8G8_SSCALED = 19, 252 VK_FORMAT_R8G8_UINT = 20, 253 VK_FORMAT_R8G8_SINT = 21, 254 VK_FORMAT_R8G8_SRGB = 22, 255 VK_FORMAT_R8G8B8_UNORM = 23, 256 VK_FORMAT_R8G8B8_SNORM = 24, 257 VK_FORMAT_R8G8B8_USCALED = 25, 258 VK_FORMAT_R8G8B8_SSCALED = 26, 259 VK_FORMAT_R8G8B8_UINT = 27, 260 VK_FORMAT_R8G8B8_SINT = 28, 261 VK_FORMAT_R8G8B8_SRGB = 29, 262 VK_FORMAT_B8G8R8_UNORM = 30, 263 VK_FORMAT_B8G8R8_SNORM = 31, 264 VK_FORMAT_B8G8R8_USCALED = 32, 265 VK_FORMAT_B8G8R8_SSCALED = 33, 266 VK_FORMAT_B8G8R8_UINT = 34, 267 VK_FORMAT_B8G8R8_SINT = 35, 268 VK_FORMAT_B8G8R8_SRGB = 36, 269 VK_FORMAT_R8G8B8A8_UNORM = 37, 270 VK_FORMAT_R8G8B8A8_SNORM = 38, 271 VK_FORMAT_R8G8B8A8_USCALED = 39, 272 VK_FORMAT_R8G8B8A8_SSCALED = 40, 273 VK_FORMAT_R8G8B8A8_UINT = 41, 274 VK_FORMAT_R8G8B8A8_SINT = 42, 275 VK_FORMAT_R8G8B8A8_SRGB = 43, 276 VK_FORMAT_B8G8R8A8_UNORM = 44, 277 VK_FORMAT_B8G8R8A8_SNORM = 45, 278 VK_FORMAT_B8G8R8A8_USCALED = 46, 279 VK_FORMAT_B8G8R8A8_SSCALED = 47, 280 VK_FORMAT_B8G8R8A8_UINT = 48, 281 VK_FORMAT_B8G8R8A8_SINT = 49, 282 VK_FORMAT_B8G8R8A8_SRGB = 50, 283 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 284 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 285 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 286 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 287 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 288 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 289 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 290 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 291 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 292 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 293 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 294 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 295 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 296 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 297 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 298 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 299 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 300 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 301 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 302 VK_FORMAT_R16_UNORM = 70, 303 VK_FORMAT_R16_SNORM = 71, 304 VK_FORMAT_R16_USCALED = 72, 305 VK_FORMAT_R16_SSCALED = 73, 306 VK_FORMAT_R16_UINT = 74, 307 VK_FORMAT_R16_SINT = 75, 308 VK_FORMAT_R16_SFLOAT = 76, 309 VK_FORMAT_R16G16_UNORM = 77, 310 VK_FORMAT_R16G16_SNORM = 78, 311 VK_FORMAT_R16G16_USCALED = 79, 312 VK_FORMAT_R16G16_SSCALED = 80, 313 VK_FORMAT_R16G16_UINT = 81, 314 VK_FORMAT_R16G16_SINT = 82, 315 VK_FORMAT_R16G16_SFLOAT = 83, 316 VK_FORMAT_R16G16B16_UNORM = 84, 317 VK_FORMAT_R16G16B16_SNORM = 85, 318 VK_FORMAT_R16G16B16_USCALED = 86, 319 VK_FORMAT_R16G16B16_SSCALED = 87, 320 VK_FORMAT_R16G16B16_UINT = 88, 321 VK_FORMAT_R16G16B16_SINT = 89, 322 VK_FORMAT_R16G16B16_SFLOAT = 90, 323 VK_FORMAT_R16G16B16A16_UNORM = 91, 324 VK_FORMAT_R16G16B16A16_SNORM = 92, 325 VK_FORMAT_R16G16B16A16_USCALED = 93, 326 VK_FORMAT_R16G16B16A16_SSCALED = 94, 327 VK_FORMAT_R16G16B16A16_UINT = 95, 328 VK_FORMAT_R16G16B16A16_SINT = 96, 329 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 330 VK_FORMAT_R32_UINT = 98, 331 VK_FORMAT_R32_SINT = 99, 332 VK_FORMAT_R32_SFLOAT = 100, 333 VK_FORMAT_R32G32_UINT = 101, 334 VK_FORMAT_R32G32_SINT = 102, 335 VK_FORMAT_R32G32_SFLOAT = 103, 336 VK_FORMAT_R32G32B32_UINT = 104, 337 VK_FORMAT_R32G32B32_SINT = 105, 338 VK_FORMAT_R32G32B32_SFLOAT = 106, 339 VK_FORMAT_R32G32B32A32_UINT = 107, 340 VK_FORMAT_R32G32B32A32_SINT = 108, 341 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 342 VK_FORMAT_R64_UINT = 110, 343 VK_FORMAT_R64_SINT = 111, 344 VK_FORMAT_R64_SFLOAT = 112, 345 VK_FORMAT_R64G64_UINT = 113, 346 VK_FORMAT_R64G64_SINT = 114, 347 VK_FORMAT_R64G64_SFLOAT = 115, 348 VK_FORMAT_R64G64B64_UINT = 116, 349 VK_FORMAT_R64G64B64_SINT = 117, 350 VK_FORMAT_R64G64B64_SFLOAT = 118, 351 VK_FORMAT_R64G64B64A64_UINT = 119, 352 VK_FORMAT_R64G64B64A64_SINT = 120, 353 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 354 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 355 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 356 VK_FORMAT_D16_UNORM = 124, 357 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 358 VK_FORMAT_D32_SFLOAT = 126, 359 VK_FORMAT_S8_UINT = 127, 360 VK_FORMAT_D16_UNORM_S8_UINT = 128, 361 VK_FORMAT_D24_UNORM_S8_UINT = 129, 362 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 363 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 364 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 365 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 366 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 367 VK_FORMAT_BC2_UNORM_BLOCK = 135, 368 VK_FORMAT_BC2_SRGB_BLOCK = 136, 369 VK_FORMAT_BC3_UNORM_BLOCK = 137, 370 VK_FORMAT_BC3_SRGB_BLOCK = 138, 371 VK_FORMAT_BC4_UNORM_BLOCK = 139, 372 VK_FORMAT_BC4_SNORM_BLOCK = 140, 373 VK_FORMAT_BC5_UNORM_BLOCK = 141, 374 VK_FORMAT_BC5_SNORM_BLOCK = 142, 375 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 376 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 377 VK_FORMAT_BC7_UNORM_BLOCK = 145, 378 VK_FORMAT_BC7_SRGB_BLOCK = 146, 379 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 380 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 381 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 382 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 383 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 384 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 385 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 386 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 387 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 388 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 389 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 390 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 391 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 392 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 393 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 394 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 395 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 396 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 397 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 398 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 399 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 400 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 401 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 402 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 403 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 404 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 405 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 406 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 407 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 408 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 409 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 410 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 411 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 412 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 413 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 414 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 415 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 416 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 417 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 418 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 419 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), 420 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 421 } 422 423 enum VkImageType { 424 VK_IMAGE_TYPE_1D = 0, 425 VK_IMAGE_TYPE_2D = 1, 426 VK_IMAGE_TYPE_3D = 2, 427 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 428 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 429 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), 430 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 431 } 432 433 enum VkImageTiling { 434 VK_IMAGE_TILING_OPTIMAL = 0, 435 VK_IMAGE_TILING_LINEAR = 1, 436 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, 437 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, 438 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), 439 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 440 } 441 442 enum VkPhysicalDeviceType { 443 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 444 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 445 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 446 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 447 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 448 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 449 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 450 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), 451 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 452 } 453 454 enum VkQueryType { 455 VK_QUERY_TYPE_OCCLUSION = 0, 456 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 457 VK_QUERY_TYPE_TIMESTAMP = 2, 458 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 459 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, 460 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), 461 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 462 } 463 464 enum VkSharingMode { 465 VK_SHARING_MODE_EXCLUSIVE = 0, 466 VK_SHARING_MODE_CONCURRENT = 1, 467 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 468 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 469 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), 470 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 471 } 472 473 enum VkImageLayout { 474 VK_IMAGE_LAYOUT_UNDEFINED = 0, 475 VK_IMAGE_LAYOUT_GENERAL = 1, 476 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 477 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 478 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 479 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 480 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 481 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 482 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 483 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 484 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 485 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 486 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), 487 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 488 } 489 490 enum VkImageViewType { 491 VK_IMAGE_VIEW_TYPE_1D = 0, 492 VK_IMAGE_VIEW_TYPE_2D = 1, 493 VK_IMAGE_VIEW_TYPE_3D = 2, 494 VK_IMAGE_VIEW_TYPE_CUBE = 3, 495 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 496 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 497 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 498 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 499 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 500 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), 501 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 502 } 503 504 enum VkComponentSwizzle { 505 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 506 VK_COMPONENT_SWIZZLE_ZERO = 1, 507 VK_COMPONENT_SWIZZLE_ONE = 2, 508 VK_COMPONENT_SWIZZLE_R = 3, 509 VK_COMPONENT_SWIZZLE_G = 4, 510 VK_COMPONENT_SWIZZLE_B = 5, 511 VK_COMPONENT_SWIZZLE_A = 6, 512 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, 513 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, 514 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), 515 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 516 } 517 518 enum VkVertexInputRate { 519 VK_VERTEX_INPUT_RATE_VERTEX = 0, 520 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 521 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, 522 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, 523 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), 524 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 525 } 526 527 enum VkPrimitiveTopology { 528 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 529 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 530 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 531 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 532 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 533 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 534 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 535 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 536 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 537 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 538 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 539 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 540 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 541 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), 542 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 543 } 544 545 enum VkPolygonMode { 546 VK_POLYGON_MODE_FILL = 0, 547 VK_POLYGON_MODE_LINE = 1, 548 VK_POLYGON_MODE_POINT = 2, 549 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, 550 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, 551 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), 552 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 553 } 554 555 enum VkFrontFace { 556 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 557 VK_FRONT_FACE_CLOCKWISE = 1, 558 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 559 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 560 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), 561 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 562 } 563 564 enum VkCompareOp { 565 VK_COMPARE_OP_NEVER = 0, 566 VK_COMPARE_OP_LESS = 1, 567 VK_COMPARE_OP_EQUAL = 2, 568 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 569 VK_COMPARE_OP_GREATER = 4, 570 VK_COMPARE_OP_NOT_EQUAL = 5, 571 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 572 VK_COMPARE_OP_ALWAYS = 7, 573 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 574 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 575 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), 576 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 577 } 578 579 enum VkStencilOp { 580 VK_STENCIL_OP_KEEP = 0, 581 VK_STENCIL_OP_ZERO = 1, 582 VK_STENCIL_OP_REPLACE = 2, 583 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 584 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 585 VK_STENCIL_OP_INVERT = 5, 586 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 587 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 588 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 589 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 590 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), 591 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 592 } 593 594 enum VkLogicOp { 595 VK_LOGIC_OP_CLEAR = 0, 596 VK_LOGIC_OP_AND = 1, 597 VK_LOGIC_OP_AND_REVERSE = 2, 598 VK_LOGIC_OP_COPY = 3, 599 VK_LOGIC_OP_AND_INVERTED = 4, 600 VK_LOGIC_OP_NO_OP = 5, 601 VK_LOGIC_OP_XOR = 6, 602 VK_LOGIC_OP_OR = 7, 603 VK_LOGIC_OP_NOR = 8, 604 VK_LOGIC_OP_EQUIVALENT = 9, 605 VK_LOGIC_OP_INVERT = 10, 606 VK_LOGIC_OP_OR_REVERSE = 11, 607 VK_LOGIC_OP_COPY_INVERTED = 12, 608 VK_LOGIC_OP_OR_INVERTED = 13, 609 VK_LOGIC_OP_NAND = 14, 610 VK_LOGIC_OP_SET = 15, 611 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 612 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 613 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), 614 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 615 } 616 617 enum VkBlendFactor { 618 VK_BLEND_FACTOR_ZERO = 0, 619 VK_BLEND_FACTOR_ONE = 1, 620 VK_BLEND_FACTOR_SRC_COLOR = 2, 621 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 622 VK_BLEND_FACTOR_DST_COLOR = 4, 623 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 624 VK_BLEND_FACTOR_SRC_ALPHA = 6, 625 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 626 VK_BLEND_FACTOR_DST_ALPHA = 8, 627 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 628 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 629 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 630 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 631 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 632 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 633 VK_BLEND_FACTOR_SRC1_COLOR = 15, 634 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 635 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 636 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 637 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, 638 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, 639 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), 640 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 641 } 642 643 enum VkBlendOp { 644 VK_BLEND_OP_ADD = 0, 645 VK_BLEND_OP_SUBTRACT = 1, 646 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 647 VK_BLEND_OP_MIN = 3, 648 VK_BLEND_OP_MAX = 4, 649 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 650 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 651 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), 652 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 653 } 654 655 enum VkDynamicState { 656 VK_DYNAMIC_STATE_VIEWPORT = 0, 657 VK_DYNAMIC_STATE_SCISSOR = 1, 658 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 659 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 660 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 661 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 662 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 663 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 664 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 665 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 666 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 667 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), 668 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 669 } 670 671 enum VkFilter { 672 VK_FILTER_NEAREST = 0, 673 VK_FILTER_LINEAR = 1, 674 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, 675 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, 676 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), 677 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 678 } 679 680 enum VkSamplerMipmapMode { 681 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 682 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 683 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, 684 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, 685 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), 686 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 687 } 688 689 enum VkSamplerAddressMode { 690 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 691 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 692 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 693 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 694 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 695 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, 696 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, 697 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), 698 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 699 } 700 701 enum VkBorderColor { 702 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 703 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 704 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 705 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 706 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 707 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 708 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 709 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 710 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), 711 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 712 } 713 714 enum VkDescriptorType { 715 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 716 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 717 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 718 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 719 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 720 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 721 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 722 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 723 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 724 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 725 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 726 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 727 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 728 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), 729 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 730 } 731 732 enum VkAttachmentLoadOp { 733 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 734 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 735 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 736 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 737 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 738 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), 739 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 740 } 741 742 enum VkAttachmentStoreOp { 743 VK_ATTACHMENT_STORE_OP_STORE = 0, 744 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 745 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 746 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 747 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), 748 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 749 } 750 751 enum VkPipelineBindPoint { 752 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 753 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 754 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 755 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 756 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), 757 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 758 } 759 760 enum VkCommandBufferLevel { 761 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 762 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 763 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 764 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 765 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), 766 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 767 } 768 769 enum VkIndexType { 770 VK_INDEX_TYPE_UINT16 = 0, 771 VK_INDEX_TYPE_UINT32 = 1, 772 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 773 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 774 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), 775 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 776 } 777 778 enum VkSubpassContents { 779 VK_SUBPASS_CONTENTS_INLINE = 0, 780 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 781 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, 782 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, 783 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), 784 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 785 } 786 787 alias VkInstanceCreateFlags = VkFlags; 788 789 enum VkFormatFeatureFlagBits { 790 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 791 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 792 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 793 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 794 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 795 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 796 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 797 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 798 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 799 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 800 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 801 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 802 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 803 } 804 805 alias VkFormatFeatureFlags = VkFlags; 806 807 enum VkImageUsageFlagBits { 808 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 809 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 810 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 811 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 812 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 813 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 814 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 815 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 816 } 817 818 alias VkImageUsageFlags = VkFlags; 819 820 enum VkImageCreateFlagBits { 821 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 822 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 823 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 824 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 825 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 826 } 827 828 alias VkImageCreateFlags = VkFlags; 829 830 enum VkSampleCountFlagBits { 831 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 832 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 833 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 834 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 835 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 836 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 837 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 838 } 839 840 alias VkSampleCountFlags = VkFlags; 841 842 enum VkQueueFlagBits { 843 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 844 VK_QUEUE_COMPUTE_BIT = 0x00000002, 845 VK_QUEUE_TRANSFER_BIT = 0x00000004, 846 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 847 } 848 849 alias VkQueueFlags = VkFlags; 850 851 enum VkMemoryPropertyFlagBits { 852 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 853 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 854 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 855 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 856 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 857 } 858 859 alias VkMemoryPropertyFlags = VkFlags; 860 861 enum VkMemoryHeapFlagBits { 862 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 863 } 864 865 alias VkMemoryHeapFlags = VkFlags; 866 867 alias VkDeviceCreateFlags = VkFlags; 868 869 alias VkDeviceQueueCreateFlags = VkFlags; 870 871 enum VkPipelineStageFlagBits { 872 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 873 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 874 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 875 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 876 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 877 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 878 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 879 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 880 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 881 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 882 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 883 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 884 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 885 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 886 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 887 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 888 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 889 } 890 891 alias VkPipelineStageFlags = VkFlags; 892 893 alias VkMemoryMapFlags = VkFlags; 894 895 enum VkImageAspectFlagBits { 896 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 897 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 898 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 899 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 900 } 901 902 alias VkImageAspectFlags = VkFlags; 903 904 enum VkSparseImageFormatFlagBits { 905 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 906 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 907 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 908 } 909 910 alias VkSparseImageFormatFlags = VkFlags; 911 912 enum VkSparseMemoryBindFlagBits { 913 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 914 } 915 916 alias VkSparseMemoryBindFlags = VkFlags; 917 918 enum VkFenceCreateFlagBits { 919 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 920 } 921 922 alias VkFenceCreateFlags = VkFlags; 923 924 alias VkSemaphoreCreateFlags = VkFlags; 925 926 alias VkEventCreateFlags = VkFlags; 927 928 alias VkQueryPoolCreateFlags = VkFlags; 929 930 enum VkQueryPipelineStatisticFlagBits { 931 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 932 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 933 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 934 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 935 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 936 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 937 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 938 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 939 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 940 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 941 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 942 } 943 944 alias VkQueryPipelineStatisticFlags = VkFlags; 945 946 enum VkQueryResultFlagBits { 947 VK_QUERY_RESULT_64_BIT = 0x00000001, 948 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 949 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 950 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 951 } 952 953 alias VkQueryResultFlags = VkFlags; 954 955 enum VkBufferCreateFlagBits { 956 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 957 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 958 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 959 } 960 961 alias VkBufferCreateFlags = VkFlags; 962 963 enum VkBufferUsageFlagBits { 964 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 965 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 966 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 967 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 968 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 969 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 970 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 971 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 972 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 973 } 974 975 alias VkBufferUsageFlags = VkFlags; 976 977 alias VkBufferViewCreateFlags = VkFlags; 978 979 alias VkImageViewCreateFlags = VkFlags; 980 981 alias VkShaderModuleCreateFlags = VkFlags; 982 983 alias VkPipelineCacheCreateFlags = VkFlags; 984 985 enum VkPipelineCreateFlagBits { 986 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 987 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 988 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 989 } 990 991 alias VkPipelineCreateFlags = VkFlags; 992 993 alias VkPipelineShaderStageCreateFlags = VkFlags; 994 995 enum VkShaderStageFlagBits { 996 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 997 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 998 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 999 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1000 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1001 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1002 VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F, 1003 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1004 } 1005 1006 alias VkPipelineVertexInputStateCreateFlags = VkFlags; 1007 1008 alias VkPipelineInputAssemblyStateCreateFlags = VkFlags; 1009 1010 alias VkPipelineTessellationStateCreateFlags = VkFlags; 1011 1012 alias VkPipelineViewportStateCreateFlags = VkFlags; 1013 1014 alias VkPipelineRasterizationStateCreateFlags = VkFlags; 1015 1016 enum VkCullModeFlagBits { 1017 VK_CULL_MODE_NONE = 0, 1018 VK_CULL_MODE_FRONT_BIT = 0x00000001, 1019 VK_CULL_MODE_BACK_BIT = 0x00000002, 1020 VK_CULL_MODE_FRONT_AND_BACK = 0x3, 1021 } 1022 1023 alias VkCullModeFlags = VkFlags; 1024 1025 alias VkPipelineMultisampleStateCreateFlags = VkFlags; 1026 1027 alias VkPipelineDepthStencilStateCreateFlags = VkFlags; 1028 1029 alias VkPipelineColorBlendStateCreateFlags = VkFlags; 1030 1031 enum VkColorComponentFlagBits { 1032 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1033 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1034 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1035 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1036 } 1037 1038 alias VkColorComponentFlags = VkFlags; 1039 1040 alias VkPipelineDynamicStateCreateFlags = VkFlags; 1041 1042 alias VkPipelineLayoutCreateFlags = VkFlags; 1043 1044 alias VkShaderStageFlags = VkFlags; 1045 1046 alias VkSamplerCreateFlags = VkFlags; 1047 1048 alias VkDescriptorSetLayoutCreateFlags = VkFlags; 1049 1050 enum VkDescriptorPoolCreateFlagBits { 1051 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1052 } 1053 1054 alias VkDescriptorPoolCreateFlags = VkFlags; 1055 1056 alias VkDescriptorPoolResetFlags = VkFlags; 1057 1058 alias VkFramebufferCreateFlags = VkFlags; 1059 1060 alias VkRenderPassCreateFlags = VkFlags; 1061 1062 enum VkAttachmentDescriptionFlagBits { 1063 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1064 } 1065 1066 alias VkAttachmentDescriptionFlags = VkFlags; 1067 1068 alias VkSubpassDescriptionFlags = VkFlags; 1069 1070 enum VkAccessFlagBits { 1071 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1072 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1073 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1074 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1075 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1076 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1077 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1078 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1079 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1080 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1081 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1082 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1083 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1084 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1085 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1086 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1087 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1088 } 1089 1090 alias VkAccessFlags = VkFlags; 1091 1092 enum VkDependencyFlagBits { 1093 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1094 } 1095 1096 alias VkDependencyFlags = VkFlags; 1097 1098 enum VkCommandPoolCreateFlagBits { 1099 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1100 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1101 } 1102 1103 alias VkCommandPoolCreateFlags = VkFlags; 1104 1105 enum VkCommandPoolResetFlagBits { 1106 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1107 } 1108 1109 alias VkCommandPoolResetFlags = VkFlags; 1110 1111 enum VkCommandBufferUsageFlagBits { 1112 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1113 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1114 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1115 } 1116 1117 alias VkCommandBufferUsageFlags = VkFlags; 1118 1119 enum VkQueryControlFlagBits { 1120 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 1121 } 1122 1123 alias VkQueryControlFlags = VkFlags; 1124 1125 enum VkCommandBufferResetFlagBits { 1126 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1127 } 1128 1129 alias VkCommandBufferResetFlags = VkFlags; 1130 1131 enum VkStencilFaceFlagBits { 1132 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1133 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1134 VK_STENCIL_FRONT_AND_BACK = 0x3, 1135 } 1136 1137 alias VkStencilFaceFlags = VkFlags; 1138 1139 alias PFN_vkAllocationFunction = nothrow void* function(void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); 1140 1141 alias PFN_vkReallocationFunction = nothrow void* function(void* pUserData, void* pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); 1142 1143 alias PFN_vkFreeFunction = nothrow void function(void* pUserData, void* pMemory); 1144 1145 alias PFN_vkInternalAllocationNotification = nothrow void function(void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope); 1146 1147 alias PFN_vkInternalFreeNotification = nothrow void function(void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope); 1148 1149 alias PFN_vkVoidFunction = nothrow void function(); 1150 1151 struct VkApplicationInfo { 1152 VkStructureType sType; 1153 const void* pNext; 1154 const char* pApplicationName; 1155 uint applicationVersion; 1156 const char* pEngineName; 1157 uint engineVersion; 1158 uint apiVersion; 1159 } 1160 1161 struct VkInstanceCreateInfo { 1162 VkStructureType sType; 1163 const void* pNext; 1164 VkInstanceCreateFlags flags; 1165 const VkApplicationInfo* pApplicationInfo; 1166 uint enabledLayerCount; 1167 const char** ppEnabledLayerNames; 1168 uint enabledExtensionCount; 1169 const char** ppEnabledExtensionNames; 1170 } 1171 1172 struct VkAllocationCallbacks { 1173 void* pUserData; 1174 PFN_vkAllocationFunction pfnAllocation; 1175 PFN_vkReallocationFunction pfnReallocation; 1176 PFN_vkFreeFunction pfnFree; 1177 PFN_vkInternalAllocationNotification pfnInternalAllocation; 1178 PFN_vkInternalFreeNotification pfnInternalFree; 1179 } 1180 1181 struct VkPhysicalDeviceFeatures { 1182 VkBool32 robustBufferAccess; 1183 VkBool32 fullDrawIndexUint32; 1184 VkBool32 imageCubeArray; 1185 VkBool32 independentBlend; 1186 VkBool32 geometryShader; 1187 VkBool32 tessellationShader; 1188 VkBool32 sampleRateShading; 1189 VkBool32 dualSrcBlend; 1190 VkBool32 logicOp; 1191 VkBool32 multiDrawIndirect; 1192 VkBool32 drawIndirectFirstInstance; 1193 VkBool32 depthClamp; 1194 VkBool32 depthBiasClamp; 1195 VkBool32 fillModeNonSolid; 1196 VkBool32 depthBounds; 1197 VkBool32 wideLines; 1198 VkBool32 largePoints; 1199 VkBool32 alphaToOne; 1200 VkBool32 multiViewport; 1201 VkBool32 samplerAnisotropy; 1202 VkBool32 textureCompressionETC2; 1203 VkBool32 textureCompressionASTC_LDR; 1204 VkBool32 textureCompressionBC; 1205 VkBool32 occlusionQueryPrecise; 1206 VkBool32 pipelineStatisticsQuery; 1207 VkBool32 vertexPipelineStoresAndAtomics; 1208 VkBool32 fragmentStoresAndAtomics; 1209 VkBool32 shaderTessellationAndGeometryPointSize; 1210 VkBool32 shaderImageGatherExtended; 1211 VkBool32 shaderStorageImageExtendedFormats; 1212 VkBool32 shaderStorageImageMultisample; 1213 VkBool32 shaderStorageImageReadWithoutFormat; 1214 VkBool32 shaderStorageImageWriteWithoutFormat; 1215 VkBool32 shaderUniformBufferArrayDynamicIndexing; 1216 VkBool32 shaderSampledImageArrayDynamicIndexing; 1217 VkBool32 shaderStorageBufferArrayDynamicIndexing; 1218 VkBool32 shaderStorageImageArrayDynamicIndexing; 1219 VkBool32 shaderClipDistance; 1220 VkBool32 shaderCullDistance; 1221 VkBool32 shaderFloat64; 1222 VkBool32 shaderInt64; 1223 VkBool32 shaderInt16; 1224 VkBool32 shaderResourceResidency; 1225 VkBool32 shaderResourceMinLod; 1226 VkBool32 sparseBinding; 1227 VkBool32 sparseResidencyBuffer; 1228 VkBool32 sparseResidencyImage2D; 1229 VkBool32 sparseResidencyImage3D; 1230 VkBool32 sparseResidency2Samples; 1231 VkBool32 sparseResidency4Samples; 1232 VkBool32 sparseResidency8Samples; 1233 VkBool32 sparseResidency16Samples; 1234 VkBool32 sparseResidencyAliased; 1235 VkBool32 variableMultisampleRate; 1236 VkBool32 inheritedQueries; 1237 } 1238 1239 struct VkFormatProperties { 1240 VkFormatFeatureFlags linearTilingFeatures; 1241 VkFormatFeatureFlags optimalTilingFeatures; 1242 VkFormatFeatureFlags bufferFeatures; 1243 } 1244 1245 struct VkExtent3D { 1246 uint width; 1247 uint height; 1248 uint depth; 1249 } 1250 1251 struct VkImageFormatProperties { 1252 VkExtent3D maxExtent; 1253 uint maxMipLevels; 1254 uint maxArrayLayers; 1255 VkSampleCountFlags sampleCounts; 1256 VkDeviceSize maxResourceSize; 1257 } 1258 1259 struct VkPhysicalDeviceLimits { 1260 uint maxImageDimension1D; 1261 uint maxImageDimension2D; 1262 uint maxImageDimension3D; 1263 uint maxImageDimensionCube; 1264 uint maxImageArrayLayers; 1265 uint maxTexelBufferElements; 1266 uint maxUniformBufferRange; 1267 uint maxStorageBufferRange; 1268 uint maxPushConstantsSize; 1269 uint maxMemoryAllocationCount; 1270 uint maxSamplerAllocationCount; 1271 VkDeviceSize bufferImageGranularity; 1272 VkDeviceSize sparseAddressSpaceSize; 1273 uint maxBoundDescriptorSets; 1274 uint maxPerStageDescriptorSamplers; 1275 uint maxPerStageDescriptorUniformBuffers; 1276 uint maxPerStageDescriptorStorageBuffers; 1277 uint maxPerStageDescriptorSampledImages; 1278 uint maxPerStageDescriptorStorageImages; 1279 uint maxPerStageDescriptorInputAttachments; 1280 uint maxPerStageResources; 1281 uint maxDescriptorSetSamplers; 1282 uint maxDescriptorSetUniformBuffers; 1283 uint maxDescriptorSetUniformBuffersDynamic; 1284 uint maxDescriptorSetStorageBuffers; 1285 uint maxDescriptorSetStorageBuffersDynamic; 1286 uint maxDescriptorSetSampledImages; 1287 uint maxDescriptorSetStorageImages; 1288 uint maxDescriptorSetInputAttachments; 1289 uint maxVertexInputAttributes; 1290 uint maxVertexInputBindings; 1291 uint maxVertexInputAttributeOffset; 1292 uint maxVertexInputBindingStride; 1293 uint maxVertexOutputComponents; 1294 uint maxTessellationGenerationLevel; 1295 uint maxTessellationPatchSize; 1296 uint maxTessellationControlPerVertexInputComponents; 1297 uint maxTessellationControlPerVertexOutputComponents; 1298 uint maxTessellationControlPerPatchOutputComponents; 1299 uint maxTessellationControlTotalOutputComponents; 1300 uint maxTessellationEvaluationInputComponents; 1301 uint maxTessellationEvaluationOutputComponents; 1302 uint maxGeometryShaderInvocations; 1303 uint maxGeometryInputComponents; 1304 uint maxGeometryOutputComponents; 1305 uint maxGeometryOutputVertices; 1306 uint maxGeometryTotalOutputComponents; 1307 uint maxFragmentInputComponents; 1308 uint maxFragmentOutputAttachments; 1309 uint maxFragmentDualSrcAttachments; 1310 uint maxFragmentCombinedOutputResources; 1311 uint maxComputeSharedMemorySize; 1312 uint[3] maxComputeWorkGroupCount; 1313 uint maxComputeWorkGroupInvocations; 1314 uint[3] maxComputeWorkGroupSize; 1315 uint subPixelPrecisionBits; 1316 uint subTexelPrecisionBits; 1317 uint mipmapPrecisionBits; 1318 uint maxDrawIndexedIndexValue; 1319 uint maxDrawIndirectCount; 1320 float maxSamplerLodBias; 1321 float maxSamplerAnisotropy; 1322 uint maxViewports; 1323 uint[2] maxViewportDimensions; 1324 float[2] viewportBoundsRange; 1325 uint viewportSubPixelBits; 1326 size_t minMemoryMapAlignment; 1327 VkDeviceSize minTexelBufferOffsetAlignment; 1328 VkDeviceSize minUniformBufferOffsetAlignment; 1329 VkDeviceSize minStorageBufferOffsetAlignment; 1330 int minTexelOffset; 1331 uint maxTexelOffset; 1332 int minTexelGatherOffset; 1333 uint maxTexelGatherOffset; 1334 float minInterpolationOffset; 1335 float maxInterpolationOffset; 1336 uint subPixelInterpolationOffsetBits; 1337 uint maxFramebufferWidth; 1338 uint maxFramebufferHeight; 1339 uint maxFramebufferLayers; 1340 VkSampleCountFlags framebufferColorSampleCounts; 1341 VkSampleCountFlags framebufferDepthSampleCounts; 1342 VkSampleCountFlags framebufferStencilSampleCounts; 1343 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 1344 uint maxColorAttachments; 1345 VkSampleCountFlags sampledImageColorSampleCounts; 1346 VkSampleCountFlags sampledImageIntegerSampleCounts; 1347 VkSampleCountFlags sampledImageDepthSampleCounts; 1348 VkSampleCountFlags sampledImageStencilSampleCounts; 1349 VkSampleCountFlags storageImageSampleCounts; 1350 uint maxSampleMaskWords; 1351 VkBool32 timestampComputeAndGraphics; 1352 float timestampPeriod; 1353 uint maxClipDistances; 1354 uint maxCullDistances; 1355 uint maxCombinedClipAndCullDistances; 1356 uint discreteQueuePriorities; 1357 float[2] pointSizeRange; 1358 float[2] lineWidthRange; 1359 float pointSizeGranularity; 1360 float lineWidthGranularity; 1361 VkBool32 strictLines; 1362 VkBool32 standardSampleLocations; 1363 VkDeviceSize optimalBufferCopyOffsetAlignment; 1364 VkDeviceSize optimalBufferCopyRowPitchAlignment; 1365 VkDeviceSize nonCoherentAtomSize; 1366 } 1367 1368 struct VkPhysicalDeviceSparseProperties { 1369 VkBool32 residencyStandard2DBlockShape; 1370 VkBool32 residencyStandard2DMultisampleBlockShape; 1371 VkBool32 residencyStandard3DBlockShape; 1372 VkBool32 residencyAlignedMipSize; 1373 VkBool32 residencyNonResidentStrict; 1374 } 1375 1376 struct VkPhysicalDeviceProperties { 1377 uint apiVersion; 1378 uint driverVersion; 1379 uint vendorID; 1380 uint deviceID; 1381 VkPhysicalDeviceType deviceType; 1382 char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName; 1383 ubyte[VK_UUID_SIZE] pipelineCacheUUID; 1384 VkPhysicalDeviceLimits limits; 1385 VkPhysicalDeviceSparseProperties sparseProperties; 1386 } 1387 1388 struct VkQueueFamilyProperties { 1389 VkQueueFlags queueFlags; 1390 uint queueCount; 1391 uint timestampValidBits; 1392 VkExtent3D minImageTransferGranularity; 1393 } 1394 1395 struct VkMemoryType { 1396 VkMemoryPropertyFlags propertyFlags; 1397 uint heapIndex; 1398 } 1399 1400 struct VkMemoryHeap { 1401 VkDeviceSize size; 1402 VkMemoryHeapFlags flags; 1403 } 1404 1405 struct VkPhysicalDeviceMemoryProperties { 1406 uint memoryTypeCount; 1407 VkMemoryType[VK_MAX_MEMORY_TYPES] memoryTypes; 1408 uint memoryHeapCount; 1409 VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps; 1410 } 1411 1412 struct VkDeviceQueueCreateInfo { 1413 VkStructureType sType; 1414 const void* pNext; 1415 VkDeviceQueueCreateFlags flags; 1416 uint queueFamilyIndex; 1417 uint queueCount; 1418 const float* pQueuePriorities; 1419 } 1420 1421 struct VkDeviceCreateInfo { 1422 VkStructureType sType; 1423 const void* pNext; 1424 VkDeviceCreateFlags flags; 1425 uint queueCreateInfoCount; 1426 const VkDeviceQueueCreateInfo* pQueueCreateInfos; 1427 uint enabledLayerCount; 1428 const char** ppEnabledLayerNames; 1429 uint enabledExtensionCount; 1430 const char** ppEnabledExtensionNames; 1431 const VkPhysicalDeviceFeatures* pEnabledFeatures; 1432 } 1433 1434 struct VkExtensionProperties { 1435 char[VK_MAX_EXTENSION_NAME_SIZE] extensionName; 1436 uint specVersion; 1437 } 1438 1439 struct VkLayerProperties { 1440 char[VK_MAX_EXTENSION_NAME_SIZE] layerName; 1441 uint specVersion; 1442 uint implementationVersion; 1443 char[VK_MAX_DESCRIPTION_SIZE] description; 1444 } 1445 1446 struct VkSubmitInfo { 1447 VkStructureType sType; 1448 const void* pNext; 1449 uint waitSemaphoreCount; 1450 const VkSemaphore* pWaitSemaphores; 1451 const VkPipelineStageFlags* pWaitDstStageMask; 1452 uint commandBufferCount; 1453 const VkCommandBuffer* pCommandBuffers; 1454 uint signalSemaphoreCount; 1455 const VkSemaphore* pSignalSemaphores; 1456 } 1457 1458 struct VkMemoryAllocateInfo { 1459 VkStructureType sType; 1460 const void* pNext; 1461 VkDeviceSize allocationSize; 1462 uint memoryTypeIndex; 1463 } 1464 1465 struct VkMappedMemoryRange { 1466 VkStructureType sType; 1467 const void* pNext; 1468 VkDeviceMemory memory; 1469 VkDeviceSize offset; 1470 VkDeviceSize size; 1471 } 1472 1473 struct VkMemoryRequirements { 1474 VkDeviceSize size; 1475 VkDeviceSize alignment; 1476 uint memoryTypeBits; 1477 } 1478 1479 struct VkSparseImageFormatProperties { 1480 VkImageAspectFlags aspectMask; 1481 VkExtent3D imageGranularity; 1482 VkSparseImageFormatFlags flags; 1483 } 1484 1485 struct VkSparseImageMemoryRequirements { 1486 VkSparseImageFormatProperties formatProperties; 1487 uint imageMipTailFirstLod; 1488 VkDeviceSize imageMipTailSize; 1489 VkDeviceSize imageMipTailOffset; 1490 VkDeviceSize imageMipTailStride; 1491 } 1492 1493 struct VkSparseMemoryBind { 1494 VkDeviceSize resourceOffset; 1495 VkDeviceSize size; 1496 VkDeviceMemory memory; 1497 VkDeviceSize memoryOffset; 1498 VkSparseMemoryBindFlags flags; 1499 } 1500 1501 struct VkSparseBufferMemoryBindInfo { 1502 VkBuffer buffer; 1503 uint bindCount; 1504 const VkSparseMemoryBind* pBinds; 1505 } 1506 1507 struct VkSparseImageOpaqueMemoryBindInfo { 1508 VkImage image; 1509 uint bindCount; 1510 const VkSparseMemoryBind* pBinds; 1511 } 1512 1513 struct VkImageSubresource { 1514 VkImageAspectFlags aspectMask; 1515 uint mipLevel; 1516 uint arrayLayer; 1517 } 1518 1519 struct VkOffset3D { 1520 int x; 1521 int y; 1522 int z; 1523 } 1524 1525 struct VkSparseImageMemoryBind { 1526 VkImageSubresource subresource; 1527 VkOffset3D offset; 1528 VkExtent3D extent; 1529 VkDeviceMemory memory; 1530 VkDeviceSize memoryOffset; 1531 VkSparseMemoryBindFlags flags; 1532 } 1533 1534 struct VkSparseImageMemoryBindInfo { 1535 VkImage image; 1536 uint bindCount; 1537 const VkSparseImageMemoryBind* pBinds; 1538 } 1539 1540 struct VkBindSparseInfo { 1541 VkStructureType sType; 1542 const void* pNext; 1543 uint waitSemaphoreCount; 1544 const VkSemaphore* pWaitSemaphores; 1545 uint bufferBindCount; 1546 const VkSparseBufferMemoryBindInfo* pBufferBinds; 1547 uint imageOpaqueBindCount; 1548 const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; 1549 uint imageBindCount; 1550 const VkSparseImageMemoryBindInfo* pImageBinds; 1551 uint signalSemaphoreCount; 1552 const VkSemaphore* pSignalSemaphores; 1553 } 1554 1555 struct VkFenceCreateInfo { 1556 VkStructureType sType; 1557 const void* pNext; 1558 VkFenceCreateFlags flags; 1559 } 1560 1561 struct VkSemaphoreCreateInfo { 1562 VkStructureType sType; 1563 const void* pNext; 1564 VkSemaphoreCreateFlags flags; 1565 } 1566 1567 struct VkEventCreateInfo { 1568 VkStructureType sType; 1569 const void* pNext; 1570 VkEventCreateFlags flags; 1571 } 1572 1573 struct VkQueryPoolCreateInfo { 1574 VkStructureType sType; 1575 const void* pNext; 1576 VkQueryPoolCreateFlags flags; 1577 VkQueryType queryType; 1578 uint queryCount; 1579 VkQueryPipelineStatisticFlags pipelineStatistics; 1580 } 1581 1582 struct VkBufferCreateInfo { 1583 VkStructureType sType; 1584 const void* pNext; 1585 VkBufferCreateFlags flags; 1586 VkDeviceSize size; 1587 VkBufferUsageFlags usage; 1588 VkSharingMode sharingMode; 1589 uint queueFamilyIndexCount; 1590 const uint* pQueueFamilyIndices; 1591 } 1592 1593 struct VkBufferViewCreateInfo { 1594 VkStructureType sType; 1595 const void* pNext; 1596 VkBufferViewCreateFlags flags; 1597 VkBuffer buffer; 1598 VkFormat format; 1599 VkDeviceSize offset; 1600 VkDeviceSize range; 1601 } 1602 1603 struct VkImageCreateInfo { 1604 VkStructureType sType; 1605 const void* pNext; 1606 VkImageCreateFlags flags; 1607 VkImageType imageType; 1608 VkFormat format; 1609 VkExtent3D extent; 1610 uint mipLevels; 1611 uint arrayLayers; 1612 VkSampleCountFlagBits samples; 1613 VkImageTiling tiling; 1614 VkImageUsageFlags usage; 1615 VkSharingMode sharingMode; 1616 uint queueFamilyIndexCount; 1617 const uint* pQueueFamilyIndices; 1618 VkImageLayout initialLayout; 1619 } 1620 1621 struct VkSubresourceLayout { 1622 VkDeviceSize offset; 1623 VkDeviceSize size; 1624 VkDeviceSize rowPitch; 1625 VkDeviceSize arrayPitch; 1626 VkDeviceSize depthPitch; 1627 } 1628 1629 struct VkComponentMapping { 1630 VkComponentSwizzle r; 1631 VkComponentSwizzle g; 1632 VkComponentSwizzle b; 1633 VkComponentSwizzle a; 1634 } 1635 1636 struct VkImageSubresourceRange { 1637 VkImageAspectFlags aspectMask; 1638 uint baseMipLevel; 1639 uint levelCount; 1640 uint baseArrayLayer; 1641 uint layerCount; 1642 } 1643 1644 struct VkImageViewCreateInfo { 1645 VkStructureType sType; 1646 const void* pNext; 1647 VkImageViewCreateFlags flags; 1648 VkImage image; 1649 VkImageViewType viewType; 1650 VkFormat format; 1651 VkComponentMapping components; 1652 VkImageSubresourceRange subresourceRange; 1653 } 1654 1655 struct VkShaderModuleCreateInfo { 1656 VkStructureType sType; 1657 const void* pNext; 1658 VkShaderModuleCreateFlags flags; 1659 size_t codeSize; 1660 const uint* pCode; 1661 } 1662 1663 struct VkPipelineCacheCreateInfo { 1664 VkStructureType sType; 1665 const void* pNext; 1666 VkPipelineCacheCreateFlags flags; 1667 size_t initialDataSize; 1668 const void* pInitialData; 1669 } 1670 1671 struct VkSpecializationMapEntry { 1672 uint constantID; 1673 uint offset; 1674 size_t size; 1675 } 1676 1677 struct VkSpecializationInfo { 1678 uint mapEntryCount; 1679 const VkSpecializationMapEntry* pMapEntries; 1680 size_t dataSize; 1681 const void* pData; 1682 } 1683 1684 struct VkPipelineShaderStageCreateInfo { 1685 VkStructureType sType; 1686 const void* pNext; 1687 VkPipelineShaderStageCreateFlags flags; 1688 VkShaderStageFlagBits stage; 1689 VkShaderModule module_; 1690 const char* pName; 1691 const VkSpecializationInfo* pSpecializationInfo; 1692 } 1693 1694 struct VkVertexInputBindingDescription { 1695 uint binding; 1696 uint stride; 1697 VkVertexInputRate inputRate; 1698 } 1699 1700 struct VkVertexInputAttributeDescription { 1701 uint location; 1702 uint binding; 1703 VkFormat format; 1704 uint offset; 1705 } 1706 1707 struct VkPipelineVertexInputStateCreateInfo { 1708 VkStructureType sType; 1709 const void* pNext; 1710 VkPipelineVertexInputStateCreateFlags flags; 1711 uint vertexBindingDescriptionCount; 1712 const VkVertexInputBindingDescription* pVertexBindingDescriptions; 1713 uint vertexAttributeDescriptionCount; 1714 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 1715 } 1716 1717 struct VkPipelineInputAssemblyStateCreateInfo { 1718 VkStructureType sType; 1719 const void* pNext; 1720 VkPipelineInputAssemblyStateCreateFlags flags; 1721 VkPrimitiveTopology topology; 1722 VkBool32 primitiveRestartEnable; 1723 } 1724 1725 struct VkPipelineTessellationStateCreateInfo { 1726 VkStructureType sType; 1727 const void* pNext; 1728 VkPipelineTessellationStateCreateFlags flags; 1729 uint patchControlPoints; 1730 } 1731 1732 struct VkViewport { 1733 float x; 1734 float y; 1735 float width; 1736 float height; 1737 float minDepth; 1738 float maxDepth; 1739 } 1740 1741 struct VkOffset2D { 1742 int x; 1743 int y; 1744 } 1745 1746 struct VkExtent2D { 1747 uint width; 1748 uint height; 1749 } 1750 1751 struct VkRect2D { 1752 VkOffset2D offset; 1753 VkExtent2D extent; 1754 } 1755 1756 struct VkPipelineViewportStateCreateInfo { 1757 VkStructureType sType; 1758 const void* pNext; 1759 VkPipelineViewportStateCreateFlags flags; 1760 uint viewportCount; 1761 const VkViewport* pViewports; 1762 uint scissorCount; 1763 const VkRect2D* pScissors; 1764 } 1765 1766 struct VkPipelineRasterizationStateCreateInfo { 1767 VkStructureType sType; 1768 const void* pNext; 1769 VkPipelineRasterizationStateCreateFlags flags; 1770 VkBool32 depthClampEnable; 1771 VkBool32 rasterizerDiscardEnable; 1772 VkPolygonMode polygonMode; 1773 VkCullModeFlags cullMode; 1774 VkFrontFace frontFace; 1775 VkBool32 depthBiasEnable; 1776 float depthBiasConstantFactor; 1777 float depthBiasClamp; 1778 float depthBiasSlopeFactor; 1779 float lineWidth; 1780 } 1781 1782 struct VkPipelineMultisampleStateCreateInfo { 1783 VkStructureType sType; 1784 const void* pNext; 1785 VkPipelineMultisampleStateCreateFlags flags; 1786 VkSampleCountFlagBits rasterizationSamples; 1787 VkBool32 sampleShadingEnable; 1788 float minSampleShading; 1789 const VkSampleMask* pSampleMask; 1790 VkBool32 alphaToCoverageEnable; 1791 VkBool32 alphaToOneEnable; 1792 } 1793 1794 struct VkStencilOpState { 1795 VkStencilOp failOp; 1796 VkStencilOp passOp; 1797 VkStencilOp depthFailOp; 1798 VkCompareOp compareOp; 1799 uint compareMask; 1800 uint writeMask; 1801 uint reference; 1802 } 1803 1804 struct VkPipelineDepthStencilStateCreateInfo { 1805 VkStructureType sType; 1806 const void* pNext; 1807 VkPipelineDepthStencilStateCreateFlags flags; 1808 VkBool32 depthTestEnable; 1809 VkBool32 depthWriteEnable; 1810 VkCompareOp depthCompareOp; 1811 VkBool32 depthBoundsTestEnable; 1812 VkBool32 stencilTestEnable; 1813 VkStencilOpState front; 1814 VkStencilOpState back; 1815 float minDepthBounds; 1816 float maxDepthBounds; 1817 } 1818 1819 struct VkPipelineColorBlendAttachmentState { 1820 VkBool32 blendEnable; 1821 VkBlendFactor srcColorBlendFactor; 1822 VkBlendFactor dstColorBlendFactor; 1823 VkBlendOp colorBlendOp; 1824 VkBlendFactor srcAlphaBlendFactor; 1825 VkBlendFactor dstAlphaBlendFactor; 1826 VkBlendOp alphaBlendOp; 1827 VkColorComponentFlags colorWriteMask; 1828 } 1829 1830 struct VkPipelineColorBlendStateCreateInfo { 1831 VkStructureType sType; 1832 const void* pNext; 1833 VkPipelineColorBlendStateCreateFlags flags; 1834 VkBool32 logicOpEnable; 1835 VkLogicOp logicOp; 1836 uint attachmentCount; 1837 const VkPipelineColorBlendAttachmentState* pAttachments; 1838 float[4] blendConstants; 1839 } 1840 1841 struct VkPipelineDynamicStateCreateInfo { 1842 VkStructureType sType; 1843 const void* pNext; 1844 VkPipelineDynamicStateCreateFlags flags; 1845 uint dynamicStateCount; 1846 const VkDynamicState* pDynamicStates; 1847 } 1848 1849 struct VkGraphicsPipelineCreateInfo { 1850 VkStructureType sType; 1851 const void* pNext; 1852 VkPipelineCreateFlags flags; 1853 uint stageCount; 1854 const VkPipelineShaderStageCreateInfo* pStages; 1855 const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1856 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1857 const VkPipelineTessellationStateCreateInfo* pTessellationState; 1858 const VkPipelineViewportStateCreateInfo* pViewportState; 1859 const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 1860 const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1861 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1862 const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1863 const VkPipelineDynamicStateCreateInfo* pDynamicState; 1864 VkPipelineLayout layout; 1865 VkRenderPass renderPass; 1866 uint subpass; 1867 VkPipeline basePipelineHandle; 1868 int basePipelineIndex; 1869 } 1870 1871 struct VkComputePipelineCreateInfo { 1872 VkStructureType sType; 1873 const void* pNext; 1874 VkPipelineCreateFlags flags; 1875 VkPipelineShaderStageCreateInfo stage; 1876 VkPipelineLayout layout; 1877 VkPipeline basePipelineHandle; 1878 int basePipelineIndex; 1879 } 1880 1881 struct VkPushConstantRange { 1882 VkShaderStageFlags stageFlags; 1883 uint offset; 1884 uint size; 1885 } 1886 1887 struct VkPipelineLayoutCreateInfo { 1888 VkStructureType sType; 1889 const void* pNext; 1890 VkPipelineLayoutCreateFlags flags; 1891 uint setLayoutCount; 1892 const VkDescriptorSetLayout* pSetLayouts; 1893 uint pushConstantRangeCount; 1894 const VkPushConstantRange* pPushConstantRanges; 1895 } 1896 1897 struct VkSamplerCreateInfo { 1898 VkStructureType sType; 1899 const void* pNext; 1900 VkSamplerCreateFlags flags; 1901 VkFilter magFilter; 1902 VkFilter minFilter; 1903 VkSamplerMipmapMode mipmapMode; 1904 VkSamplerAddressMode addressModeU; 1905 VkSamplerAddressMode addressModeV; 1906 VkSamplerAddressMode addressModeW; 1907 float mipLodBias; 1908 VkBool32 anisotropyEnable; 1909 float maxAnisotropy; 1910 VkBool32 compareEnable; 1911 VkCompareOp compareOp; 1912 float minLod; 1913 float maxLod; 1914 VkBorderColor borderColor; 1915 VkBool32 unnormalizedCoordinates; 1916 } 1917 1918 struct VkDescriptorSetLayoutBinding { 1919 uint binding; 1920 VkDescriptorType descriptorType; 1921 uint descriptorCount; 1922 VkShaderStageFlags stageFlags; 1923 const VkSampler* pImmutableSamplers; 1924 } 1925 1926 struct VkDescriptorSetLayoutCreateInfo { 1927 VkStructureType sType; 1928 const void* pNext; 1929 VkDescriptorSetLayoutCreateFlags flags; 1930 uint bindingCount; 1931 const VkDescriptorSetLayoutBinding* pBindings; 1932 } 1933 1934 struct VkDescriptorPoolSize { 1935 VkDescriptorType type; 1936 uint descriptorCount; 1937 } 1938 1939 struct VkDescriptorPoolCreateInfo { 1940 VkStructureType sType; 1941 const void* pNext; 1942 VkDescriptorPoolCreateFlags flags; 1943 uint maxSets; 1944 uint poolSizeCount; 1945 const VkDescriptorPoolSize* pPoolSizes; 1946 } 1947 1948 struct VkDescriptorSetAllocateInfo { 1949 VkStructureType sType; 1950 const void* pNext; 1951 VkDescriptorPool descriptorPool; 1952 uint descriptorSetCount; 1953 const VkDescriptorSetLayout* pSetLayouts; 1954 } 1955 1956 struct VkDescriptorImageInfo { 1957 VkSampler sampler; 1958 VkImageView imageView; 1959 VkImageLayout imageLayout; 1960 } 1961 1962 struct VkDescriptorBufferInfo { 1963 VkBuffer buffer; 1964 VkDeviceSize offset; 1965 VkDeviceSize range; 1966 } 1967 1968 struct VkWriteDescriptorSet { 1969 VkStructureType sType; 1970 const void* pNext; 1971 VkDescriptorSet dstSet; 1972 uint dstBinding; 1973 uint dstArrayElement; 1974 uint descriptorCount; 1975 VkDescriptorType descriptorType; 1976 const VkDescriptorImageInfo* pImageInfo; 1977 const VkDescriptorBufferInfo* pBufferInfo; 1978 const VkBufferView* pTexelBufferView; 1979 } 1980 1981 struct VkCopyDescriptorSet { 1982 VkStructureType sType; 1983 const void* pNext; 1984 VkDescriptorSet srcSet; 1985 uint srcBinding; 1986 uint srcArrayElement; 1987 VkDescriptorSet dstSet; 1988 uint dstBinding; 1989 uint dstArrayElement; 1990 uint descriptorCount; 1991 } 1992 1993 struct VkFramebufferCreateInfo { 1994 VkStructureType sType; 1995 const void* pNext; 1996 VkFramebufferCreateFlags flags; 1997 VkRenderPass renderPass; 1998 uint attachmentCount; 1999 const VkImageView* pAttachments; 2000 uint width; 2001 uint height; 2002 uint layers; 2003 } 2004 2005 struct VkAttachmentDescription { 2006 VkAttachmentDescriptionFlags flags; 2007 VkFormat format; 2008 VkSampleCountFlagBits samples; 2009 VkAttachmentLoadOp loadOp; 2010 VkAttachmentStoreOp storeOp; 2011 VkAttachmentLoadOp stencilLoadOp; 2012 VkAttachmentStoreOp stencilStoreOp; 2013 VkImageLayout initialLayout; 2014 VkImageLayout finalLayout; 2015 } 2016 2017 struct VkAttachmentReference { 2018 uint attachment; 2019 VkImageLayout layout; 2020 } 2021 2022 struct VkSubpassDescription { 2023 VkSubpassDescriptionFlags flags; 2024 VkPipelineBindPoint pipelineBindPoint; 2025 uint inputAttachmentCount; 2026 const VkAttachmentReference* pInputAttachments; 2027 uint colorAttachmentCount; 2028 const VkAttachmentReference* pColorAttachments; 2029 const VkAttachmentReference* pResolveAttachments; 2030 const VkAttachmentReference* pDepthStencilAttachment; 2031 uint preserveAttachmentCount; 2032 const uint* pPreserveAttachments; 2033 } 2034 2035 struct VkSubpassDependency { 2036 uint srcSubpass; 2037 uint dstSubpass; 2038 VkPipelineStageFlags srcStageMask; 2039 VkPipelineStageFlags dstStageMask; 2040 VkAccessFlags srcAccessMask; 2041 VkAccessFlags dstAccessMask; 2042 VkDependencyFlags dependencyFlags; 2043 } 2044 2045 struct VkRenderPassCreateInfo { 2046 VkStructureType sType; 2047 const void* pNext; 2048 VkRenderPassCreateFlags flags; 2049 uint attachmentCount; 2050 const VkAttachmentDescription* pAttachments; 2051 uint subpassCount; 2052 const VkSubpassDescription* pSubpasses; 2053 uint dependencyCount; 2054 const VkSubpassDependency* pDependencies; 2055 } 2056 2057 struct VkCommandPoolCreateInfo { 2058 VkStructureType sType; 2059 const void* pNext; 2060 VkCommandPoolCreateFlags flags; 2061 uint queueFamilyIndex; 2062 } 2063 2064 struct VkCommandBufferAllocateInfo { 2065 VkStructureType sType; 2066 const void* pNext; 2067 VkCommandPool commandPool; 2068 VkCommandBufferLevel level; 2069 uint commandBufferCount; 2070 } 2071 2072 struct VkCommandBufferInheritanceInfo { 2073 VkStructureType sType; 2074 const void* pNext; 2075 VkRenderPass renderPass; 2076 uint subpass; 2077 VkFramebuffer framebuffer; 2078 VkBool32 occlusionQueryEnable; 2079 VkQueryControlFlags queryFlags; 2080 VkQueryPipelineStatisticFlags pipelineStatistics; 2081 } 2082 2083 struct VkCommandBufferBeginInfo { 2084 VkStructureType sType; 2085 const void* pNext; 2086 VkCommandBufferUsageFlags flags; 2087 const VkCommandBufferInheritanceInfo* pInheritanceInfo; 2088 } 2089 2090 struct VkBufferCopy { 2091 VkDeviceSize srcOffset; 2092 VkDeviceSize dstOffset; 2093 VkDeviceSize size; 2094 } 2095 2096 struct VkImageSubresourceLayers { 2097 VkImageAspectFlags aspectMask; 2098 uint mipLevel; 2099 uint baseArrayLayer; 2100 uint layerCount; 2101 } 2102 2103 struct VkImageCopy { 2104 VkImageSubresourceLayers srcSubresource; 2105 VkOffset3D srcOffset; 2106 VkImageSubresourceLayers dstSubresource; 2107 VkOffset3D dstOffset; 2108 VkExtent3D extent; 2109 } 2110 2111 struct VkImageBlit { 2112 VkImageSubresourceLayers srcSubresource; 2113 VkOffset3D[2] srcOffsets; 2114 VkImageSubresourceLayers dstSubresource; 2115 VkOffset3D[2] dstOffsets; 2116 } 2117 2118 struct VkBufferImageCopy { 2119 VkDeviceSize bufferOffset; 2120 uint bufferRowLength; 2121 uint bufferImageHeight; 2122 VkImageSubresourceLayers imageSubresource; 2123 VkOffset3D imageOffset; 2124 VkExtent3D imageExtent; 2125 } 2126 2127 union VkClearColorValue { 2128 float[4] float32; 2129 int[4] int32; 2130 uint[4] uint32; 2131 } 2132 2133 struct VkClearDepthStencilValue { 2134 float depth; 2135 uint stencil; 2136 } 2137 2138 union VkClearValue { 2139 VkClearColorValue color; 2140 VkClearDepthStencilValue depthStencil; 2141 } 2142 2143 struct VkClearAttachment { 2144 VkImageAspectFlags aspectMask; 2145 uint colorAttachment; 2146 VkClearValue clearValue; 2147 } 2148 2149 struct VkClearRect { 2150 VkRect2D rect; 2151 uint baseArrayLayer; 2152 uint layerCount; 2153 } 2154 2155 struct VkImageResolve { 2156 VkImageSubresourceLayers srcSubresource; 2157 VkOffset3D srcOffset; 2158 VkImageSubresourceLayers dstSubresource; 2159 VkOffset3D dstOffset; 2160 VkExtent3D extent; 2161 } 2162 2163 struct VkMemoryBarrier { 2164 VkStructureType sType; 2165 const void* pNext; 2166 VkAccessFlags srcAccessMask; 2167 VkAccessFlags dstAccessMask; 2168 } 2169 2170 struct VkBufferMemoryBarrier { 2171 VkStructureType sType; 2172 const void* pNext; 2173 VkAccessFlags srcAccessMask; 2174 VkAccessFlags dstAccessMask; 2175 uint srcQueueFamilyIndex; 2176 uint dstQueueFamilyIndex; 2177 VkBuffer buffer; 2178 VkDeviceSize offset; 2179 VkDeviceSize size; 2180 } 2181 2182 struct VkImageMemoryBarrier { 2183 VkStructureType sType; 2184 const void* pNext; 2185 VkAccessFlags srcAccessMask; 2186 VkAccessFlags dstAccessMask; 2187 VkImageLayout oldLayout; 2188 VkImageLayout newLayout; 2189 uint srcQueueFamilyIndex; 2190 uint dstQueueFamilyIndex; 2191 VkImage image; 2192 VkImageSubresourceRange subresourceRange; 2193 } 2194 2195 struct VkRenderPassBeginInfo { 2196 VkStructureType sType; 2197 const void* pNext; 2198 VkRenderPass renderPass; 2199 VkFramebuffer framebuffer; 2200 VkRect2D renderArea; 2201 uint clearValueCount; 2202 const VkClearValue* pClearValues; 2203 } 2204 2205 struct VkDispatchIndirectCommand { 2206 uint x; 2207 uint y; 2208 uint z; 2209 } 2210 2211 struct VkDrawIndexedIndirectCommand { 2212 uint indexCount; 2213 uint instanceCount; 2214 uint firstIndex; 2215 int vertexOffset; 2216 uint firstInstance; 2217 } 2218 2219 struct VkDrawIndirectCommand { 2220 uint vertexCount; 2221 uint instanceCount; 2222 uint firstVertex; 2223 uint firstInstance; 2224 } 2225 2226 alias PFN_vkCreateInstance = nothrow VkResult function(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2227 alias PFN_vkDestroyInstance = nothrow void function(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2228 alias PFN_vkEnumeratePhysicalDevices = nothrow VkResult function(VkInstance instance, uint* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2229 alias PFN_vkGetPhysicalDeviceFeatures = nothrow void function(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2230 alias PFN_vkGetPhysicalDeviceFormatProperties = nothrow void function(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2231 alias PFN_vkGetPhysicalDeviceImageFormatProperties = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2232 alias PFN_vkGetPhysicalDeviceProperties = nothrow void function(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2233 alias PFN_vkGetPhysicalDeviceQueueFamilyProperties = nothrow void function(VkPhysicalDevice physicalDevice, uint* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2234 alias PFN_vkGetPhysicalDeviceMemoryProperties = nothrow void function(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2235 alias PFN_vkGetInstanceProcAddr = nothrow PFN_vkVoidFunction function(VkInstance instance, const char* pName); 2236 alias PFN_vkGetDeviceProcAddr = nothrow PFN_vkVoidFunction function(VkDevice device, const char* pName); 2237 alias PFN_vkCreateDevice = nothrow VkResult function(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2238 alias PFN_vkDestroyDevice = nothrow void function(VkDevice device, const VkAllocationCallbacks* pAllocator); 2239 alias PFN_vkEnumerateInstanceExtensionProperties = nothrow VkResult function(const char* pLayerName, uint* pPropertyCount, VkExtensionProperties* pProperties); 2240 alias PFN_vkEnumerateDeviceExtensionProperties = nothrow VkResult function(VkPhysicalDevice physicalDevice, const char* pLayerName, uint* pPropertyCount, VkExtensionProperties* pProperties); 2241 alias PFN_vkEnumerateInstanceLayerProperties = nothrow VkResult function(uint* pPropertyCount, VkLayerProperties* pProperties); 2242 alias PFN_vkEnumerateDeviceLayerProperties = nothrow VkResult function(VkPhysicalDevice physicalDevice, uint* pPropertyCount, VkLayerProperties* pProperties); 2243 alias PFN_vkGetDeviceQueue = nothrow void function(VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue* pQueue); 2244 alias PFN_vkQueueSubmit = nothrow VkResult function(VkQueue queue, uint submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2245 alias PFN_vkQueueWaitIdle = nothrow VkResult function(VkQueue queue); 2246 alias PFN_vkDeviceWaitIdle = nothrow VkResult function(VkDevice device); 2247 alias PFN_vkAllocateMemory = nothrow VkResult function(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2248 alias PFN_vkFreeMemory = nothrow void function(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2249 alias PFN_vkMapMemory = nothrow VkResult function(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2250 alias PFN_vkUnmapMemory = nothrow void function(VkDevice device, VkDeviceMemory memory); 2251 alias PFN_vkFlushMappedMemoryRanges = nothrow VkResult function(VkDevice device, uint memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2252 alias PFN_vkInvalidateMappedMemoryRanges = nothrow VkResult function(VkDevice device, uint memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2253 alias PFN_vkGetDeviceMemoryCommitment = nothrow void function(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2254 alias PFN_vkBindBufferMemory = nothrow VkResult function(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2255 alias PFN_vkBindImageMemory = nothrow VkResult function(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2256 alias PFN_vkGetBufferMemoryRequirements = nothrow void function(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2257 alias PFN_vkGetImageMemoryRequirements = nothrow void function(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2258 alias PFN_vkGetImageSparseMemoryRequirements = nothrow void function(VkDevice device, VkImage image, uint* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2259 alias PFN_vkGetPhysicalDeviceSparseImageFormatProperties = nothrow void function(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2260 alias PFN_vkQueueBindSparse = nothrow VkResult function(VkQueue queue, uint bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2261 alias PFN_vkCreateFence = nothrow VkResult function(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2262 alias PFN_vkDestroyFence = nothrow void function(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2263 alias PFN_vkResetFences = nothrow VkResult function(VkDevice device, uint fenceCount, const VkFence* pFences); 2264 alias PFN_vkGetFenceStatus = nothrow VkResult function(VkDevice device, VkFence fence); 2265 alias PFN_vkWaitForFences = nothrow VkResult function(VkDevice device, uint fenceCount, const VkFence* pFences, VkBool32 waitAll, ulong timeout); 2266 alias PFN_vkCreateSemaphore = nothrow VkResult function(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2267 alias PFN_vkDestroySemaphore = nothrow void function(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2268 alias PFN_vkCreateEvent = nothrow VkResult function(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2269 alias PFN_vkDestroyEvent = nothrow void function(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2270 alias PFN_vkGetEventStatus = nothrow VkResult function(VkDevice device, VkEvent event); 2271 alias PFN_vkSetEvent = nothrow VkResult function(VkDevice device, VkEvent event); 2272 alias PFN_vkResetEvent = nothrow VkResult function(VkDevice device, VkEvent event); 2273 alias PFN_vkCreateQueryPool = nothrow VkResult function(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2274 alias PFN_vkDestroyQueryPool = nothrow void function(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2275 alias PFN_vkGetQueryPoolResults = nothrow VkResult function(VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); 2276 alias PFN_vkCreateBuffer = nothrow VkResult function(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2277 alias PFN_vkDestroyBuffer = nothrow void function(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2278 alias PFN_vkCreateBufferView = nothrow VkResult function(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2279 alias PFN_vkDestroyBufferView = nothrow void function(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2280 alias PFN_vkCreateImage = nothrow VkResult function(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2281 alias PFN_vkDestroyImage = nothrow void function(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2282 alias PFN_vkGetImageSubresourceLayout = nothrow void function(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2283 alias PFN_vkCreateImageView = nothrow VkResult function(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2284 alias PFN_vkDestroyImageView = nothrow void function(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2285 alias PFN_vkCreateShaderModule = nothrow VkResult function(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2286 alias PFN_vkDestroyShaderModule = nothrow void function(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2287 alias PFN_vkCreatePipelineCache = nothrow VkResult function(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2288 alias PFN_vkDestroyPipelineCache = nothrow void function(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2289 alias PFN_vkGetPipelineCacheData = nothrow VkResult function(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2290 alias PFN_vkMergePipelineCaches = nothrow VkResult function(VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, const VkPipelineCache* pSrcCaches); 2291 alias PFN_vkCreateGraphicsPipelines = nothrow VkResult function(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2292 alias PFN_vkCreateComputePipelines = nothrow VkResult function(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2293 alias PFN_vkDestroyPipeline = nothrow void function(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2294 alias PFN_vkCreatePipelineLayout = nothrow VkResult function(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2295 alias PFN_vkDestroyPipelineLayout = nothrow void function(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2296 alias PFN_vkCreateSampler = nothrow VkResult function(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2297 alias PFN_vkDestroySampler = nothrow void function(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2298 alias PFN_vkCreateDescriptorSetLayout = nothrow VkResult function(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2299 alias PFN_vkDestroyDescriptorSetLayout = nothrow void function(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2300 alias PFN_vkCreateDescriptorPool = nothrow VkResult function(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2301 alias PFN_vkDestroyDescriptorPool = nothrow void function(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2302 alias PFN_vkResetDescriptorPool = nothrow VkResult function(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2303 alias PFN_vkAllocateDescriptorSets = nothrow VkResult function(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2304 alias PFN_vkFreeDescriptorSets = nothrow VkResult function(VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2305 alias PFN_vkUpdateDescriptorSets = nothrow void function(VkDevice device, uint descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2306 alias PFN_vkCreateFramebuffer = nothrow VkResult function(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2307 alias PFN_vkDestroyFramebuffer = nothrow void function(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2308 alias PFN_vkCreateRenderPass = nothrow VkResult function(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2309 alias PFN_vkDestroyRenderPass = nothrow void function(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2310 alias PFN_vkGetRenderAreaGranularity = nothrow void function(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2311 alias PFN_vkCreateCommandPool = nothrow VkResult function(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2312 alias PFN_vkDestroyCommandPool = nothrow void function(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); 2313 alias PFN_vkResetCommandPool = nothrow VkResult function(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 2314 alias PFN_vkAllocateCommandBuffers = nothrow VkResult function(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2315 alias PFN_vkFreeCommandBuffers = nothrow void function(VkDevice device, VkCommandPool commandPool, uint commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2316 alias PFN_vkBeginCommandBuffer = nothrow VkResult function(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2317 alias PFN_vkEndCommandBuffer = nothrow VkResult function(VkCommandBuffer commandBuffer); 2318 alias PFN_vkResetCommandBuffer = nothrow VkResult function(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2319 alias PFN_vkCmdBindPipeline = nothrow void function(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2320 alias PFN_vkCmdSetViewport = nothrow void function(VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, const VkViewport* pViewports); 2321 alias PFN_vkCmdSetScissor = nothrow void function(VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, const VkRect2D* pScissors); 2322 alias PFN_vkCmdSetLineWidth = nothrow void function(VkCommandBuffer commandBuffer, float lineWidth); 2323 alias PFN_vkCmdSetDepthBias = nothrow void function(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2324 alias PFN_vkCmdSetBlendConstants = nothrow void function(VkCommandBuffer commandBuffer, const float[4] blendConstants); 2325 alias PFN_vkCmdSetDepthBounds = nothrow void function(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2326 alias PFN_vkCmdSetStencilCompareMask = nothrow void function(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask); 2327 alias PFN_vkCmdSetStencilWriteMask = nothrow void function(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask); 2328 alias PFN_vkCmdSetStencilReference = nothrow void function(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference); 2329 alias PFN_vkCmdBindDescriptorSets = nothrow void function(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint dynamicOffsetCount, const uint* pDynamicOffsets); 2330 alias PFN_vkCmdBindIndexBuffer = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2331 alias PFN_vkCmdBindVertexBuffers = nothrow void function(VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2332 alias PFN_vkCmdDraw = nothrow void function(VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance); 2333 alias PFN_vkCmdDrawIndexed = nothrow void function(VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance); 2334 alias PFN_vkCmdDrawIndirect = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride); 2335 alias PFN_vkCmdDrawIndexedIndirect = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride); 2336 alias PFN_vkCmdDispatch = nothrow void function(VkCommandBuffer commandBuffer, uint x, uint y, uint z); 2337 alias PFN_vkCmdDispatchIndirect = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2338 alias PFN_vkCmdCopyBuffer = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, const VkBufferCopy* pRegions); 2339 alias PFN_vkCmdCopyImage = nothrow void function(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkImageCopy* pRegions); 2340 alias PFN_vkCmdBlitImage = nothrow void function(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkImageBlit* pRegions, VkFilter filter); 2341 alias PFN_vkCmdCopyBufferToImage = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkBufferImageCopy* pRegions); 2342 alias PFN_vkCmdCopyImageToBuffer = nothrow void function(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, const VkBufferImageCopy* pRegions); 2343 alias PFN_vkCmdUpdateBuffer = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint* pData); 2344 alias PFN_vkCmdFillBuffer = nothrow void function(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data); 2345 alias PFN_vkCmdClearColorImage = nothrow void function(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint rangeCount, const VkImageSubresourceRange* pRanges); 2346 alias PFN_vkCmdClearDepthStencilImage = nothrow void function(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint rangeCount, const VkImageSubresourceRange* pRanges); 2347 alias PFN_vkCmdClearAttachments = nothrow void function(VkCommandBuffer commandBuffer, uint attachmentCount, const VkClearAttachment* pAttachments, uint rectCount, const VkClearRect* pRects); 2348 alias PFN_vkCmdResolveImage = nothrow void function(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkImageResolve* pRegions); 2349 alias PFN_vkCmdSetEvent = nothrow void function(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2350 alias PFN_vkCmdResetEvent = nothrow void function(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2351 alias PFN_vkCmdWaitEvents = nothrow void function(VkCommandBuffer commandBuffer, uint eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); 2352 alias PFN_vkCmdPipelineBarrier = nothrow void function(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); 2353 alias PFN_vkCmdBeginQuery = nothrow void function(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags); 2354 alias PFN_vkCmdEndQuery = nothrow void function(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query); 2355 alias PFN_vkCmdResetQueryPool = nothrow void function(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount); 2356 alias PFN_vkCmdWriteTimestamp = nothrow void function(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query); 2357 alias PFN_vkCmdCopyQueryPoolResults = nothrow void function(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2358 alias PFN_vkCmdPushConstants = nothrow void function(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, const void* pValues); 2359 alias PFN_vkCmdBeginRenderPass = nothrow void function(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 2360 alias PFN_vkCmdNextSubpass = nothrow void function(VkCommandBuffer commandBuffer, VkSubpassContents contents); 2361 alias PFN_vkCmdEndRenderPass = nothrow void function(VkCommandBuffer commandBuffer); 2362 alias PFN_vkCmdExecuteCommands = nothrow void function(VkCommandBuffer commandBuffer, uint commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2363 2364 version (none) { 2365 extern (C) VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); 2366 2367 extern (C) void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator); 2368 2369 extern (C) VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 2370 2371 extern (C) void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 2372 2373 extern (C) void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 2374 2375 extern (C) VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 2376 2377 extern (C) void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 2378 2379 extern (C) void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 2380 2381 extern (C) void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 2382 2383 extern (C) PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName); 2384 2385 extern (C) PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName); 2386 2387 extern (C) VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); 2388 2389 extern (C) void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); 2390 2391 extern (C) VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint* pPropertyCount, VkExtensionProperties* pProperties); 2392 2393 extern (C) VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint* pPropertyCount, VkExtensionProperties* pProperties); 2394 2395 extern (C) VkResult vkEnumerateInstanceLayerProperties(uint* pPropertyCount, VkLayerProperties* pProperties); 2396 2397 extern (C) VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint* pPropertyCount, VkLayerProperties* pProperties); 2398 2399 extern (C) void vkGetDeviceQueue(VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue* pQueue); 2400 2401 extern (C) VkResult vkQueueSubmit(VkQueue queue, uint submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 2402 2403 extern (C) VkResult vkQueueWaitIdle(VkQueue queue); 2404 2405 extern (C) VkResult vkDeviceWaitIdle(VkDevice device); 2406 2407 extern (C) VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 2408 2409 extern (C) void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 2410 2411 extern (C) VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 2412 2413 extern (C) void vkUnmapMemory(VkDevice device, VkDeviceMemory memory); 2414 2415 extern (C) VkResult vkFlushMappedMemoryRanges(VkDevice device, uint memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2416 2417 extern (C) VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 2418 2419 extern (C) void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 2420 2421 extern (C) VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2422 2423 extern (C) VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 2424 2425 extern (C) void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 2426 2427 extern (C) void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 2428 2429 extern (C) void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 2430 2431 extern (C) void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint* pPropertyCount, VkSparseImageFormatProperties* pProperties); 2432 2433 extern (C) VkResult vkQueueBindSparse(VkQueue queue, uint bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 2434 2435 extern (C) VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 2436 2437 extern (C) void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 2438 2439 extern (C) VkResult vkResetFences(VkDevice device, uint fenceCount, const VkFence* pFences); 2440 2441 extern (C) VkResult vkGetFenceStatus(VkDevice device, VkFence fence); 2442 2443 extern (C) VkResult vkWaitForFences(VkDevice device, uint fenceCount, const VkFence* pFences, VkBool32 waitAll, ulong timeout); 2444 2445 extern (C) VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 2446 2447 extern (C) void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 2448 2449 extern (C) VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 2450 2451 extern (C) void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 2452 2453 extern (C) VkResult vkGetEventStatus(VkDevice device, VkEvent event); 2454 2455 extern (C) VkResult vkSetEvent(VkDevice device, VkEvent event); 2456 2457 extern (C) VkResult vkResetEvent(VkDevice device, VkEvent event); 2458 2459 extern (C) VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 2460 2461 extern (C) void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 2462 2463 extern (C) VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); 2464 2465 extern (C) VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 2466 2467 extern (C) void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 2468 2469 extern (C) VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 2470 2471 extern (C) void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 2472 2473 extern (C) VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 2474 2475 extern (C) void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 2476 2477 extern (C) void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 2478 2479 extern (C) VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 2480 2481 extern (C) void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 2482 2483 extern (C) VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 2484 2485 extern (C) void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 2486 2487 extern (C) VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 2488 2489 extern (C) void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 2490 2491 extern (C) VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 2492 2493 extern (C) VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, const VkPipelineCache* pSrcCaches); 2494 2495 extern (C) VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2496 2497 extern (C) VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 2498 2499 extern (C) void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 2500 2501 extern (C) VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 2502 2503 extern (C) void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 2504 2505 extern (C) VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 2506 2507 extern (C) void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 2508 2509 extern (C) VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 2510 2511 extern (C) void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 2512 2513 extern (C) VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 2514 2515 extern (C) void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 2516 2517 extern (C) VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 2518 2519 extern (C) VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 2520 2521 extern (C) VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 2522 2523 extern (C) void vkUpdateDescriptorSets(VkDevice device, uint descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 2524 2525 extern (C) VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 2526 2527 extern (C) void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 2528 2529 extern (C) VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 2530 2531 extern (C) void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 2532 2533 extern (C) void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 2534 2535 extern (C) VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 2536 2537 extern (C) void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); 2538 2539 extern (C) VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 2540 2541 extern (C) VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 2542 2543 extern (C) void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2544 2545 extern (C) VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 2546 2547 extern (C) VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer); 2548 2549 extern (C) VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 2550 2551 extern (C) void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 2552 2553 extern (C) void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, const VkViewport* pViewports); 2554 2555 extern (C) void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, const VkRect2D* pScissors); 2556 2557 extern (C) void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); 2558 2559 extern (C) void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 2560 2561 extern (C) void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float[4] blendConstants); 2562 2563 extern (C) void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 2564 2565 extern (C) void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask); 2566 2567 extern (C) void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask); 2568 2569 extern (C) void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference); 2570 2571 extern (C) void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint dynamicOffsetCount, const uint* pDynamicOffsets); 2572 2573 extern (C) void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 2574 2575 extern (C) void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 2576 2577 extern (C) void vkCmdDraw(VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance); 2578 2579 extern (C) void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance); 2580 2581 extern (C) void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride); 2582 2583 extern (C) void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride); 2584 2585 extern (C) void vkCmdDispatch(VkCommandBuffer commandBuffer, uint x, uint y, uint z); 2586 2587 extern (C) void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 2588 2589 extern (C) void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, const VkBufferCopy* pRegions); 2590 2591 extern (C) void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkImageCopy* pRegions); 2592 2593 extern (C) void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkImageBlit* pRegions, VkFilter filter); 2594 2595 extern (C) void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkBufferImageCopy* pRegions); 2596 2597 extern (C) void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, const VkBufferImageCopy* pRegions); 2598 2599 extern (C) void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint* pData); 2600 2601 extern (C) void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data); 2602 2603 extern (C) void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint rangeCount, const VkImageSubresourceRange* pRanges); 2604 2605 extern (C) void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint rangeCount, const VkImageSubresourceRange* pRanges); 2606 2607 extern (C) void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint attachmentCount, const VkClearAttachment* pAttachments, uint rectCount, const VkClearRect* pRects); 2608 2609 extern (C) void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, const VkImageResolve* pRegions); 2610 2611 extern (C) void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2612 2613 extern (C) void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 2614 2615 extern (C) void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); 2616 2617 extern (C) void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); 2618 2619 extern (C) void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags); 2620 2621 extern (C) void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query); 2622 2623 extern (C) void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount); 2624 2625 extern (C) void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query); 2626 2627 extern (C) void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 2628 2629 extern (C) void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, const void* pValues); 2630 2631 extern (C) void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 2632 2633 extern (C) void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); 2634 2635 extern (C) void vkCmdEndRenderPass(VkCommandBuffer commandBuffer); 2636 2637 extern (C) void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint commandBufferCount, const VkCommandBuffer* pCommandBuffers); 2638 } 2639 2640 enum VK_KHR_surface = 1; 2641 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkSurfaceKHR")); 2642 2643 enum VK_KHR_SURFACE_SPEC_VERSION = 25; 2644 enum VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface"; 2645 2646 enum VkColorSpaceKHR { 2647 VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, 2648 VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 2649 VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, 2650 VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), 2651 VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF 2652 } 2653 2654 enum VkPresentModeKHR { 2655 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 2656 VK_PRESENT_MODE_MAILBOX_KHR = 1, 2657 VK_PRESENT_MODE_FIFO_KHR = 2, 2658 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 2659 VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, 2660 VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 2661 VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), 2662 VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF 2663 } 2664 2665 enum VkSurfaceTransformFlagBitsKHR { 2666 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 2667 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 2668 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 2669 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 2670 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 2671 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 2672 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 2673 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 2674 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 2675 } 2676 2677 alias VkSurfaceTransformFlagsKHR = VkFlags; 2678 2679 enum VkCompositeAlphaFlagBitsKHR { 2680 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 2681 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 2682 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 2683 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 2684 } 2685 2686 alias VkCompositeAlphaFlagsKHR = VkFlags; 2687 2688 struct VkSurfaceCapabilitiesKHR { 2689 uint minImageCount; 2690 uint maxImageCount; 2691 VkExtent2D currentExtent; 2692 VkExtent2D minImageExtent; 2693 VkExtent2D maxImageExtent; 2694 uint maxImageArrayLayers; 2695 VkSurfaceTransformFlagsKHR supportedTransforms; 2696 VkSurfaceTransformFlagBitsKHR currentTransform; 2697 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 2698 VkImageUsageFlags supportedUsageFlags; 2699 } 2700 2701 struct VkSurfaceFormatKHR { 2702 VkFormat format; 2703 VkColorSpaceKHR colorSpace; 2704 } 2705 2706 alias PFN_vkDestroySurfaceKHR = nothrow void function(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 2707 alias PFN_vkGetPhysicalDeviceSurfaceSupportKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 2708 alias PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 2709 alias PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 2710 alias PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint* pPresentModeCount, VkPresentModeKHR* pPresentModes); 2711 2712 version (none) { 2713 extern (C) void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 2714 2715 extern (C) VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 2716 2717 extern (C) VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 2718 2719 extern (C) VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 2720 2721 extern (C) VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint* pPresentModeCount, VkPresentModeKHR* pPresentModes); 2722 } 2723 2724 enum VK_KHR_swapchain = 1; 2725 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkSwapchainKHR")); 2726 2727 enum VK_KHR_SWAPCHAIN_SPEC_VERSION = 67; 2728 enum VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain"; 2729 2730 alias VkSwapchainCreateFlagsKHR = VkFlags; 2731 2732 struct VkSwapchainCreateInfoKHR { 2733 VkStructureType sType; 2734 const void* pNext; 2735 VkSwapchainCreateFlagsKHR flags; 2736 VkSurfaceKHR surface; 2737 uint minImageCount; 2738 VkFormat imageFormat; 2739 VkColorSpaceKHR imageColorSpace; 2740 VkExtent2D imageExtent; 2741 uint imageArrayLayers; 2742 VkImageUsageFlags imageUsage; 2743 VkSharingMode imageSharingMode; 2744 uint queueFamilyIndexCount; 2745 const uint* pQueueFamilyIndices; 2746 VkSurfaceTransformFlagBitsKHR preTransform; 2747 VkCompositeAlphaFlagBitsKHR compositeAlpha; 2748 VkPresentModeKHR presentMode; 2749 VkBool32 clipped; 2750 VkSwapchainKHR oldSwapchain; 2751 } 2752 2753 struct VkPresentInfoKHR { 2754 VkStructureType sType; 2755 const void* pNext; 2756 uint waitSemaphoreCount; 2757 const VkSemaphore* pWaitSemaphores; 2758 uint swapchainCount; 2759 const VkSwapchainKHR* pSwapchains; 2760 const uint* pImageIndices; 2761 VkResult* pResults; 2762 } 2763 2764 alias PFN_vkCreateSwapchainKHR = nothrow VkResult function(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 2765 alias PFN_vkDestroySwapchainKHR = nothrow void function(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); 2766 alias PFN_vkGetSwapchainImagesKHR = nothrow VkResult function(VkDevice device, VkSwapchainKHR swapchain, uint* pSwapchainImageCount, VkImage* pSwapchainImages); 2767 alias PFN_vkAcquireNextImageKHR = nothrow VkResult function(VkDevice device, VkSwapchainKHR swapchain, ulong timeout, VkSemaphore semaphore, VkFence fence, uint* pImageIndex); 2768 alias PFN_vkQueuePresentKHR = nothrow VkResult function(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 2769 2770 version (none) { 2771 extern (C) VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 2772 2773 extern (C) void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); 2774 2775 extern (C) VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint* pSwapchainImageCount, VkImage* pSwapchainImages); 2776 2777 extern (C) VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, ulong timeout, VkSemaphore semaphore, VkFence fence, uint* pImageIndex); 2778 2779 extern (C) VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 2780 } 2781 2782 enum VK_KHR_display = 1; 2783 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDisplayKHR")); 2784 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDisplayModeKHR")); 2785 2786 enum VK_KHR_DISPLAY_SPEC_VERSION = 21; 2787 enum VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display"; 2788 2789 enum VkDisplayPlaneAlphaFlagBitsKHR { 2790 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 2791 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 2792 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 2793 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 2794 } 2795 2796 alias VkDisplayModeCreateFlagsKHR = VkFlags; 2797 alias VkDisplayPlaneAlphaFlagsKHR = VkFlags; 2798 alias VkDisplaySurfaceCreateFlagsKHR = VkFlags; 2799 2800 struct VkDisplayPropertiesKHR { 2801 VkDisplayKHR display; 2802 const char* displayName; 2803 VkExtent2D physicalDimensions; 2804 VkExtent2D physicalResolution; 2805 VkSurfaceTransformFlagsKHR supportedTransforms; 2806 VkBool32 planeReorderPossible; 2807 VkBool32 persistentContent; 2808 } 2809 2810 struct VkDisplayModeParametersKHR { 2811 VkExtent2D visibleRegion; 2812 uint refreshRate; 2813 } 2814 2815 struct VkDisplayModePropertiesKHR { 2816 VkDisplayModeKHR displayMode; 2817 VkDisplayModeParametersKHR parameters; 2818 } 2819 2820 struct VkDisplayModeCreateInfoKHR { 2821 VkStructureType sType; 2822 const void* pNext; 2823 VkDisplayModeCreateFlagsKHR flags; 2824 VkDisplayModeParametersKHR parameters; 2825 } 2826 2827 struct VkDisplayPlaneCapabilitiesKHR { 2828 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 2829 VkOffset2D minSrcPosition; 2830 VkOffset2D maxSrcPosition; 2831 VkExtent2D minSrcExtent; 2832 VkExtent2D maxSrcExtent; 2833 VkOffset2D minDstPosition; 2834 VkOffset2D maxDstPosition; 2835 VkExtent2D minDstExtent; 2836 VkExtent2D maxDstExtent; 2837 } 2838 2839 struct VkDisplayPlanePropertiesKHR { 2840 VkDisplayKHR currentDisplay; 2841 uint currentStackIndex; 2842 } 2843 2844 struct VkDisplaySurfaceCreateInfoKHR { 2845 VkStructureType sType; 2846 const void* pNext; 2847 VkDisplaySurfaceCreateFlagsKHR flags; 2848 VkDisplayModeKHR displayMode; 2849 uint planeIndex; 2850 uint planeStackIndex; 2851 VkSurfaceTransformFlagBitsKHR transform; 2852 float globalAlpha; 2853 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 2854 VkExtent2D imageExtent; 2855 } 2856 2857 alias PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, uint* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 2858 alias PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, uint* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 2859 alias PFN_vkGetDisplayPlaneSupportedDisplaysKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, uint planeIndex, uint* pDisplayCount, VkDisplayKHR* pDisplays); 2860 alias PFN_vkGetDisplayModePropertiesKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 2861 alias PFN_vkCreateDisplayModeKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); 2862 alias PFN_vkGetDisplayPlaneCapabilitiesKHR = nothrow VkResult function(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 2863 alias PFN_vkCreateDisplayPlaneSurfaceKHR = nothrow VkResult function(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2864 2865 version (none) { 2866 extern (C) VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint* pPropertyCount, VkDisplayPropertiesKHR* pProperties); 2867 2868 extern (C) VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); 2869 2870 extern (C) VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint planeIndex, uint* pDisplayCount, VkDisplayKHR* pDisplays); 2871 2872 extern (C) VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); 2873 2874 extern (C) VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); 2875 2876 extern (C) VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); 2877 2878 extern (C) VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2879 } 2880 2881 enum VK_KHR_display_swapchain = 1; 2882 enum VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 9; 2883 enum VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_display_swapchain"; 2884 2885 struct VkDisplayPresentInfoKHR { 2886 VkStructureType sType; 2887 const void* pNext; 2888 VkRect2D srcRect; 2889 VkRect2D dstRect; 2890 VkBool32 persistent; 2891 } 2892 2893 alias PFN_vkCreateSharedSwapchainsKHR = nothrow VkResult function(VkDevice device, uint swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); 2894 2895 version (none) { 2896 extern (C) VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); 2897 } 2898 2899 version (VK_USE_PLATFORM_XLIB_KHR) { 2900 enum VK_KHR_xlib_surface = 1; 2901 //#include <X11/Xlib.h> 2902 2903 enum VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; 2904 enum VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; 2905 2906 alias VkXlibSurfaceCreateFlagsKHR = VkFlags; 2907 2908 struct VkXlibSurfaceCreateInfoKHR { 2909 VkStructureType sType; 2910 const void* pNext; 2911 VkXlibSurfaceCreateFlagsKHR flags; 2912 Display* dpy; 2913 Window window; 2914 } 2915 2916 alias PFN_vkCreateXlibSurfaceKHR = nothrow VkResult function(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2917 alias PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = nothrow VkBool32 function(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, Display* dpy, VisualID visualID); 2918 2919 version (none) { 2920 extern (C) VkResult vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2921 2922 extern (C) VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, Display* dpy, VisualID visualID); 2923 } 2924 } 2925 2926 version (VK_USE_PLATFORM_XCB_KHR) { 2927 enum VK_KHR_xcb_surface = 1; 2928 //#include <xcb/xcb.h> 2929 2930 enum VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; 2931 enum VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; 2932 2933 alias VkXcbSurfaceCreateFlagsKHR = VkFlags; 2934 2935 struct VkXcbSurfaceCreateInfoKHR { 2936 VkStructureType sType; 2937 const void* pNext; 2938 VkXcbSurfaceCreateFlagsKHR flags; 2939 xcb_connection_t* connection; 2940 xcb_window_t window; 2941 } 2942 2943 alias PFN_vkCreateXcbSurfaceKHR = nothrow VkResult function(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2944 alias PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = nothrow VkBool32 function(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); 2945 2946 version (none) { 2947 extern (C) VkResult vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2948 2949 extern (C) VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); 2950 } 2951 } 2952 2953 version (VK_USE_PLATFORM_WAYLAND_KHR) { 2954 enum VK_KHR_wayland_surface = 1; 2955 //#include <wayland-client.h> 2956 2957 enum VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 5; 2958 enum VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; 2959 2960 alias VkWaylandSurfaceCreateFlagsKHR = VkFlags; 2961 2962 struct VkWaylandSurfaceCreateInfoKHR { 2963 VkStructureType sType; 2964 const void* pNext; 2965 VkWaylandSurfaceCreateFlagsKHR flags; 2966 wl_display* display; 2967 wl_surface* surface; 2968 } 2969 2970 alias PFN_vkCreateWaylandSurfaceKHR = nothrow VkResult function(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2971 alias PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = nothrow VkBool32 function(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, wl_display* display); 2972 2973 version (none) { 2974 extern (C) VkResult vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2975 2976 extern (C) VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, wl_display* display); 2977 } 2978 } 2979 2980 version (VK_USE_PLATFORM_MIR_KHR) { 2981 enum VK_KHR_mir_surface = 1; 2982 //#include <mir_toolkit/client_types.h> 2983 2984 enum VK_KHR_MIR_SURFACE_SPEC_VERSION = 4; 2985 enum VK_KHR_MIR_SURFACE_EXTENSION_NAME = "VK_KHR_mir_surface"; 2986 2987 alias VkMirSurfaceCreateFlagsKHR = VkFlags; 2988 2989 struct VkMirSurfaceCreateInfoKHR { 2990 VkStructureType sType; 2991 const void* pNext; 2992 VkMirSurfaceCreateFlagsKHR flags; 2993 MirConnection* connection; 2994 MirSurface* mirSurface; 2995 } 2996 2997 alias PFN_vkCreateMirSurfaceKHR = nothrow VkResult function(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 2998 alias PFN_vkGetPhysicalDeviceMirPresentationSupportKHR = nothrow VkBool32 function(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, MirConnection* connection); 2999 3000 version (none) { 3001 extern (C) VkResult vkCreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3002 3003 extern (C) VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex, MirConnection* connection); 3004 } 3005 } 3006 3007 version (VK_USE_PLATFORM_ANDROID_KHR) { 3008 enum VK_KHR_android_surface = 1; 3009 //#include <android/native_window.h> 3010 3011 enum VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; 3012 enum VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; 3013 3014 alias VkAndroidSurfaceCreateFlagsKHR = VkFlags; 3015 3016 struct VkAndroidSurfaceCreateInfoKHR { 3017 VkStructureType sType; 3018 const void* pNext; 3019 VkAndroidSurfaceCreateFlagsKHR flags; 3020 ANativeWindow* window; 3021 } 3022 3023 alias PFN_vkCreateAndroidSurfaceKHR = nothrow VkResult function(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3024 3025 version (none) { 3026 extern (C) VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3027 } 3028 } 3029 3030 version (VK_USE_PLATFORM_WIN32_KHR) { 3031 enum VK_KHR_win32_surface = 1; 3032 //#include <windows.h> 3033 3034 enum VK_KHR_WIN32_SURFACE_SPEC_VERSION = 5; 3035 enum VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; 3036 3037 alias VkWin32SurfaceCreateFlagsKHR = VkFlags; 3038 3039 struct VkWin32SurfaceCreateInfoKHR { 3040 VkStructureType sType; 3041 const void* pNext; 3042 VkWin32SurfaceCreateFlagsKHR flags; 3043 HINSTANCE hinstance; 3044 HWND hwnd; 3045 } 3046 3047 alias PFN_vkCreateWin32SurfaceKHR = nothrow VkResult function(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3048 alias PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = nothrow VkBool32 function(VkPhysicalDevice physicalDevice, uint queueFamilyIndex); 3049 3050 version (none) { 3051 extern (C) VkResult vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 3052 3053 extern (C) VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint queueFamilyIndex); 3054 } 3055 } 3056 3057 enum VK_EXT_debug_report = 1; 3058 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE("VkDebugReportCallbackEXT")); 3059 3060 enum VK_EXT_DEBUG_REPORT_SPEC_VERSION = 1; 3061 enum VK_EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report"; 3062 3063 enum VkDebugReportObjectTypeEXT { 3064 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, 3065 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, 3066 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, 3067 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, 3068 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, 3069 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, 3070 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, 3071 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, 3072 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, 3073 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, 3074 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, 3075 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, 3076 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, 3077 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, 3078 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, 3079 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, 3080 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, 3081 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, 3082 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, 3083 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, 3084 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, 3085 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, 3086 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, 3087 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, 3088 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, 3089 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, 3090 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, 3091 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, 3092 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, 3093 } 3094 3095 enum VkDebugReportErrorEXT { 3096 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, 3097 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, 3098 } 3099 3100 enum VkDebugReportFlagBitsEXT { 3101 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, 3102 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, 3103 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, 3104 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, 3105 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, 3106 } 3107 3108 alias VkDebugReportFlagsEXT = VkFlags; 3109 3110 alias PFN_vkDebugReportCallbackEXT = nothrow VkBool32 function(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, ulong object, size_t location, int messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData); 3111 3112 struct VkDebugReportCallbackCreateInfoEXT { 3113 VkStructureType sType; 3114 const void* pNext; 3115 VkDebugReportFlagsEXT flags; 3116 PFN_vkDebugReportCallbackEXT pfnCallback; 3117 void* pUserData; 3118 } 3119 3120 alias PFN_vkCreateDebugReportCallbackEXT = nothrow VkResult function(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); 3121 alias PFN_vkDestroyDebugReportCallbackEXT = nothrow void function(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); 3122 alias PFN_vkDebugReportMessageEXT = nothrow void function(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, ulong object, size_t location, int messageCode, const char* pLayerPrefix, const char* pMessage); 3123 3124 version (none) { 3125 extern (C) VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); 3126 3127 extern (C) void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); 3128 3129 extern (C) void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, ulong object, size_t location, int messageCode, const char* pLayerPrefix, const char* pMessage); 3130 }