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