vulkan.api revision d27f6aad91e6cdb7a867c432f66a852acc077897
1// Copyright (c) 2015 The Khronos Group Inc. 2// 3// Permission is hereby granted, free of charge, to any person obtaining a 4// copy of this software and/or associated documentation files (the 5// "Materials"), to deal in the Materials without restriction, including 6// without limitation the rights to use, copy, modify, merge, publish, 7// distribute, sublicense, and/or sell copies of the Materials, and to 8// permit persons to whom the Materials are furnished to do so, subject to 9// the following conditions: 10// 11// The above copyright notice and this permission notice shall be included 12// in all copies or substantial portions of the Materials. 13// 14// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 17// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 18// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 19// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 20// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. 21 22import platform "platform.api" 23 24/////////////// 25// Constants // 26/////////////// 27 28// API version (major.minor.patch) 29define VERSION_MAJOR 0 30define VERSION_MINOR 138 31define VERSION_PATCH 0 32 33// API limits 34define VK_MAX_PHYSICAL_DEVICE_NAME 256 35define VK_UUID_LENGTH 16 36define VK_MAX_EXTENSION_NAME 256 37define VK_MAX_DESCRIPTION 256 38define VK_MAX_MEMORY_TYPES 32 39define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types. 40 41// API keywords 42define VK_TRUE 1 43define VK_FALSE 0 44define VK_NULL_HANDLE 0 45 46 47///////////// 48// Types // 49///////////// 50 51/// Dispatchable handle types. 52@dispatchHandle type u64 VkInstance 53@dispatchHandle type u64 VkPhysicalDevice 54@dispatchHandle type u64 VkDevice 55@dispatchHandle type u64 VkQueue 56@dispatchHandle type u64 VkCmdBuffer 57 58/// Non dispatchable handle types. 59@nonDispatchHandle type u64 VkDeviceMemory 60@nonDispatchHandle type u64 VkCmdPool 61@nonDispatchHandle type u64 VkBuffer 62@nonDispatchHandle type u64 VkBufferView 63@nonDispatchHandle type u64 VkImage 64@nonDispatchHandle type u64 VkImageView 65@nonDispatchHandle type u64 VkAttachmentView 66@nonDispatchHandle type u64 VkShaderModule 67@nonDispatchHandle type u64 VkShader 68@nonDispatchHandle type u64 VkPipeline 69@nonDispatchHandle type u64 VkPipelineLayout 70@nonDispatchHandle type u64 VkSampler 71@nonDispatchHandle type u64 VkDescriptorSet 72@nonDispatchHandle type u64 VkDescriptorSetLayout 73@nonDispatchHandle type u64 VkDescriptorPool 74@nonDispatchHandle type u64 VkDynamicViewportState 75@nonDispatchHandle type u64 VkDynamicRasterState 76@nonDispatchHandle type u64 VkDynamicColorBlendState 77@nonDispatchHandle type u64 VkDynamicDepthStencilState 78@nonDispatchHandle type u64 VkFence 79@nonDispatchHandle type u64 VkSemaphore 80@nonDispatchHandle type u64 VkEvent 81@nonDispatchHandle type u64 VkQueryPool 82@nonDispatchHandle type u64 VkFramebuffer 83@nonDispatchHandle type u64 VkRenderPass 84@nonDispatchHandle type u64 VkPipelineCache 85 86 87///////////// 88// Enums // 89///////////// 90 91enum VkImageLayout { 92 VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, /// Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) 93 VK_IMAGE_LAYOUT_GENERAL = 0x00000001, /// General layout when image can be used for any kind of access 94 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, /// Optimal layout when image is only used for color attachment read/write 95 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, /// Optimal layout when image is only used for depth/stencil attachment read/write 96 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, /// Optimal layout when image is used for read only depth/stencil attachment and shader access 97 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, /// Optimal layout when image is used for read only shader access 98 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations 99 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations 100} 101 102enum VkAttachmentLoadOp { 103 VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, 104 VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, 105 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002, 106} 107 108enum VkAttachmentStoreOp { 109 VK_ATTACHMENT_STORE_OP_STORE = 0x00000000, 110 VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000001, 111} 112 113enum VkImageType { 114 VK_IMAGE_TYPE_1D = 0x00000000, 115 VK_IMAGE_TYPE_2D = 0x00000001, 116 VK_IMAGE_TYPE_3D = 0x00000002, 117} 118 119enum VkImageTiling { 120 VK_IMAGE_TILING_LINEAR = 0x00000000, 121 VK_IMAGE_TILING_OPTIMAL = 0x00000001, 122} 123 124enum VkImageViewType { 125 VK_IMAGE_VIEW_TYPE_1D = 0x00000000, 126 VK_IMAGE_VIEW_TYPE_2D = 0x00000001, 127 VK_IMAGE_VIEW_TYPE_3D = 0x00000002, 128 VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003, 129 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 0x00000004, 130 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 0x00000005, 131 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006, 132} 133 134enum VkImageAspect { 135 VK_IMAGE_ASPECT_COLOR = 0x00000000, 136 VK_IMAGE_ASPECT_DEPTH = 0x00000001, 137 VK_IMAGE_ASPECT_STENCIL = 0x00000002, 138 VK_IMAGE_ASPECT_METADATA = 0x00000003, 139} 140 141enum VkBufferViewType { 142 VK_BUFFER_VIEW_TYPE_RAW = 0x00000000, /// Raw buffer without special structure (UBO, SSBO) 143 VK_BUFFER_VIEW_TYPE_FORMATTED = 0x00000001, /// Buffer with format (TBO, IBO) 144} 145 146enum VkCmdBufferLevel { 147 VK_CMD_BUFFER_LEVEL_PRIMARY = 0x00000000, 148 VK_CMD_BUFFER_LEVEL_SECONDARY = 0x00000001, 149} 150 151enum VkChannelSwizzle { 152 VK_CHANNEL_SWIZZLE_ZERO = 0x00000000, 153 VK_CHANNEL_SWIZZLE_ONE = 0x00000001, 154 VK_CHANNEL_SWIZZLE_R = 0x00000002, 155 VK_CHANNEL_SWIZZLE_G = 0x00000003, 156 VK_CHANNEL_SWIZZLE_B = 0x00000004, 157 VK_CHANNEL_SWIZZLE_A = 0x00000005, 158} 159 160enum VkDescriptorType { 161 VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000, 162 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001, 163 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002, 164 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003, 165 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004, 166 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005, 167 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006, 168 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007, 169 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008, 170 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009, 171 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 0x0000000a, 172} 173 174enum VkDescriptorPoolUsage { 175 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000, 176 VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001, 177} 178 179enum VkDescriptorSetUsage { 180 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000, 181 VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001, 182} 183 184enum VkQueryType { 185 VK_QUERY_TYPE_OCCLUSION = 0x00000000, 186 VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional 187} 188 189enum VkTimestampType { 190 VK_TIMESTAMP_TYPE_TOP = 0x00000000, 191 VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001, 192} 193 194enum VkBorderColor { 195 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0x00000000, 196 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 0x00000001, 197 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 0x00000002, 198 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 0x00000003, 199 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 0x00000004, 200 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 0x00000005, 201} 202 203enum VkPipelineBindPoint { 204 VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000, 205 VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001, 206} 207 208enum VkPrimitiveTopology { 209 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000, 210 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001, 211 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002, 212 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003, 213 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, 214 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005, 215 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006, 216 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007, 217 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008, 218 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009, 219 VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a, 220} 221 222enum VkSharingMode { 223 VK_SHARING_MODE_EXCLUSIVE = 0x00000000, 224 VK_SHARING_MODE_CONCURRENT = 0x00000001, 225} 226 227enum VkIndexType { 228 VK_INDEX_TYPE_UINT16 = 0x00000000, 229 VK_INDEX_TYPE_UINT32 = 0x00000001, 230} 231 232enum VkTexFilter { 233 VK_TEX_FILTER_NEAREST = 0x00000000, 234 VK_TEX_FILTER_LINEAR = 0x00000001, 235} 236 237enum VkTexMipmapMode { 238 VK_TEX_MIPMAP_MODE_BASE = 0x00000000, /// Always choose base level 239 VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001, /// Choose nearest mip level 240 VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002, /// Linear filter between mip levels 241} 242 243enum VkTexAddress { 244 VK_TEX_ADDRESS_WRAP = 0x00000000, 245 VK_TEX_ADDRESS_MIRROR = 0x00000001, 246 VK_TEX_ADDRESS_CLAMP = 0x00000002, 247 VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003, 248 VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004, 249} 250 251enum VkCompareOp { 252 VK_COMPARE_OP_NEVER = 0x00000000, 253 VK_COMPARE_OP_LESS = 0x00000001, 254 VK_COMPARE_OP_EQUAL = 0x00000002, 255 VK_COMPARE_OP_LESS_EQUAL = 0x00000003, 256 VK_COMPARE_OP_GREATER = 0x00000004, 257 VK_COMPARE_OP_NOT_EQUAL = 0x00000005, 258 VK_COMPARE_OP_GREATER_EQUAL = 0x00000006, 259 VK_COMPARE_OP_ALWAYS = 0x00000007, 260} 261 262enum VkFillMode { 263 VK_FILL_MODE_POINTS = 0x00000000, 264 VK_FILL_MODE_WIREFRAME = 0x00000001, 265 VK_FILL_MODE_SOLID = 0x00000002, 266} 267 268enum VkCullMode { 269 VK_CULL_MODE_NONE = 0x00000000, 270 VK_CULL_MODE_FRONT = 0x00000001, 271 VK_CULL_MODE_BACK = 0x00000002, 272 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 273} 274 275enum VkFrontFace { 276 VK_FRONT_FACE_CCW = 0x00000000, 277 VK_FRONT_FACE_CW = 0x00000001, 278} 279 280enum VkBlend { 281 VK_BLEND_ZERO = 0x00000000, 282 VK_BLEND_ONE = 0x00000001, 283 VK_BLEND_SRC_COLOR = 0x00000002, 284 VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003, 285 VK_BLEND_DEST_COLOR = 0x00000004, 286 VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005, 287 VK_BLEND_SRC_ALPHA = 0x00000006, 288 VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007, 289 VK_BLEND_DEST_ALPHA = 0x00000008, 290 VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009, 291 VK_BLEND_CONSTANT_COLOR = 0x0000000a, 292 VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b, 293 VK_BLEND_CONSTANT_ALPHA = 0x0000000c, 294 VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d, 295 VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e, 296 VK_BLEND_SRC1_COLOR = 0x0000000f, 297 VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010, 298 VK_BLEND_SRC1_ALPHA = 0x00000011, 299 VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012, 300} 301 302enum VkBlendOp { 303 VK_BLEND_OP_ADD = 0x00000000, 304 VK_BLEND_OP_SUBTRACT = 0x00000001, 305 VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002, 306 VK_BLEND_OP_MIN = 0x00000003, 307 VK_BLEND_OP_MAX = 0x00000004, 308} 309 310enum VkStencilOp { 311 VK_STENCIL_OP_KEEP = 0x00000000, 312 VK_STENCIL_OP_ZERO = 0x00000001, 313 VK_STENCIL_OP_REPLACE = 0x00000002, 314 VK_STENCIL_OP_INC_CLAMP = 0x00000003, 315 VK_STENCIL_OP_DEC_CLAMP = 0x00000004, 316 VK_STENCIL_OP_INVERT = 0x00000005, 317 VK_STENCIL_OP_INC_WRAP = 0x00000006, 318 VK_STENCIL_OP_DEC_WRAP = 0x00000007, 319} 320 321enum VkLogicOp { 322 VK_LOGIC_OP_CLEAR = 0x00000000, 323 VK_LOGIC_OP_AND = 0x00000001, 324 VK_LOGIC_OP_AND_REVERSE = 0x00000002, 325 VK_LOGIC_OP_COPY = 0x00000003, 326 VK_LOGIC_OP_AND_INVERTED = 0x00000004, 327 VK_LOGIC_OP_NOOP = 0x00000005, 328 VK_LOGIC_OP_XOR = 0x00000006, 329 VK_LOGIC_OP_OR = 0x00000007, 330 VK_LOGIC_OP_NOR = 0x00000008, 331 VK_LOGIC_OP_EQUIV = 0x00000009, 332 VK_LOGIC_OP_INVERT = 0x0000000a, 333 VK_LOGIC_OP_OR_REVERSE = 0x0000000b, 334 VK_LOGIC_OP_COPY_INVERTED = 0x0000000c, 335 VK_LOGIC_OP_OR_INVERTED = 0x0000000d, 336 VK_LOGIC_OP_NAND = 0x0000000e, 337 VK_LOGIC_OP_SET = 0x0000000f, 338} 339 340enum VkSystemAllocType { 341 VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000, 342 VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001, 343 VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002, 344 VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003, 345 VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004, 346} 347 348enum VkPhysicalDeviceType { 349 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000, 350 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001, 351 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002, 352 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003, 353 VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004, 354} 355 356enum VkVertexInputStepRate { 357 VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x00000000, 358 VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x00000001, 359} 360 361/// Vulkan format definitions 362enum VkFormat { 363 VK_FORMAT_UNDEFINED = 0x00000000, 364 VK_FORMAT_R4G4_UNORM = 0x00000001, 365 VK_FORMAT_R4G4_USCALED = 0x00000002, 366 VK_FORMAT_R4G4B4A4_UNORM = 0x00000003, 367 VK_FORMAT_R4G4B4A4_USCALED = 0x00000004, 368 VK_FORMAT_R5G6B5_UNORM = 0x00000005, 369 VK_FORMAT_R5G6B5_USCALED = 0x00000006, 370 VK_FORMAT_R5G5B5A1_UNORM = 0x00000007, 371 VK_FORMAT_R5G5B5A1_USCALED = 0x00000008, 372 VK_FORMAT_R8_UNORM = 0x00000009, 373 VK_FORMAT_R8_SNORM = 0x0000000A, 374 VK_FORMAT_R8_USCALED = 0x0000000B, 375 VK_FORMAT_R8_SSCALED = 0x0000000C, 376 VK_FORMAT_R8_UINT = 0x0000000D, 377 VK_FORMAT_R8_SINT = 0x0000000E, 378 VK_FORMAT_R8_SRGB = 0x0000000F, 379 VK_FORMAT_R8G8_UNORM = 0x00000010, 380 VK_FORMAT_R8G8_SNORM = 0x00000011, 381 VK_FORMAT_R8G8_USCALED = 0x00000012, 382 VK_FORMAT_R8G8_SSCALED = 0x00000013, 383 VK_FORMAT_R8G8_UINT = 0x00000014, 384 VK_FORMAT_R8G8_SINT = 0x00000015, 385 VK_FORMAT_R8G8_SRGB = 0x00000016, 386 VK_FORMAT_R8G8B8_UNORM = 0x00000017, 387 VK_FORMAT_R8G8B8_SNORM = 0x00000018, 388 VK_FORMAT_R8G8B8_USCALED = 0x00000019, 389 VK_FORMAT_R8G8B8_SSCALED = 0x0000001A, 390 VK_FORMAT_R8G8B8_UINT = 0x0000001B, 391 VK_FORMAT_R8G8B8_SINT = 0x0000001C, 392 VK_FORMAT_R8G8B8_SRGB = 0x0000001D, 393 VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E, 394 VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F, 395 VK_FORMAT_R8G8B8A8_USCALED = 0x00000020, 396 VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021, 397 VK_FORMAT_R8G8B8A8_UINT = 0x00000022, 398 VK_FORMAT_R8G8B8A8_SINT = 0x00000023, 399 VK_FORMAT_R8G8B8A8_SRGB = 0x00000024, 400 VK_FORMAT_R10G10B10A2_UNORM = 0x00000025, 401 VK_FORMAT_R10G10B10A2_SNORM = 0x00000026, 402 VK_FORMAT_R10G10B10A2_USCALED = 0x00000027, 403 VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028, 404 VK_FORMAT_R10G10B10A2_UINT = 0x00000029, 405 VK_FORMAT_R10G10B10A2_SINT = 0x0000002A, 406 VK_FORMAT_R16_UNORM = 0x0000002B, 407 VK_FORMAT_R16_SNORM = 0x0000002C, 408 VK_FORMAT_R16_USCALED = 0x0000002D, 409 VK_FORMAT_R16_SSCALED = 0x0000002E, 410 VK_FORMAT_R16_UINT = 0x0000002F, 411 VK_FORMAT_R16_SINT = 0x00000030, 412 VK_FORMAT_R16_SFLOAT = 0x00000031, 413 VK_FORMAT_R16G16_UNORM = 0x00000032, 414 VK_FORMAT_R16G16_SNORM = 0x00000033, 415 VK_FORMAT_R16G16_USCALED = 0x00000034, 416 VK_FORMAT_R16G16_SSCALED = 0x00000035, 417 VK_FORMAT_R16G16_UINT = 0x00000036, 418 VK_FORMAT_R16G16_SINT = 0x00000037, 419 VK_FORMAT_R16G16_SFLOAT = 0x00000038, 420 VK_FORMAT_R16G16B16_UNORM = 0x00000039, 421 VK_FORMAT_R16G16B16_SNORM = 0x0000003A, 422 VK_FORMAT_R16G16B16_USCALED = 0x0000003B, 423 VK_FORMAT_R16G16B16_SSCALED = 0x0000003C, 424 VK_FORMAT_R16G16B16_UINT = 0x0000003D, 425 VK_FORMAT_R16G16B16_SINT = 0x0000003E, 426 VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F, 427 VK_FORMAT_R16G16B16A16_UNORM = 0x00000040, 428 VK_FORMAT_R16G16B16A16_SNORM = 0x00000041, 429 VK_FORMAT_R16G16B16A16_USCALED = 0x00000042, 430 VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043, 431 VK_FORMAT_R16G16B16A16_UINT = 0x00000044, 432 VK_FORMAT_R16G16B16A16_SINT = 0x00000045, 433 VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046, 434 VK_FORMAT_R32_UINT = 0x00000047, 435 VK_FORMAT_R32_SINT = 0x00000048, 436 VK_FORMAT_R32_SFLOAT = 0x00000049, 437 VK_FORMAT_R32G32_UINT = 0x0000004A, 438 VK_FORMAT_R32G32_SINT = 0x0000004B, 439 VK_FORMAT_R32G32_SFLOAT = 0x0000004C, 440 VK_FORMAT_R32G32B32_UINT = 0x0000004D, 441 VK_FORMAT_R32G32B32_SINT = 0x0000004E, 442 VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F, 443 VK_FORMAT_R32G32B32A32_UINT = 0x00000050, 444 VK_FORMAT_R32G32B32A32_SINT = 0x00000051, 445 VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052, 446 VK_FORMAT_R64_SFLOAT = 0x00000053, 447 VK_FORMAT_R64G64_SFLOAT = 0x00000054, 448 VK_FORMAT_R64G64B64_SFLOAT = 0x00000055, 449 VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056, 450 VK_FORMAT_R11G11B10_UFLOAT = 0x00000057, 451 VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058, 452 VK_FORMAT_D16_UNORM = 0x00000059, 453 VK_FORMAT_D24_UNORM = 0x0000005A, 454 VK_FORMAT_D32_SFLOAT = 0x0000005B, 455 VK_FORMAT_S8_UINT = 0x0000005C, 456 VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D, 457 VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E, 458 VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F, 459 VK_FORMAT_BC1_RGB_UNORM = 0x00000060, 460 VK_FORMAT_BC1_RGB_SRGB = 0x00000061, 461 VK_FORMAT_BC1_RGBA_UNORM = 0x00000062, 462 VK_FORMAT_BC1_RGBA_SRGB = 0x00000063, 463 VK_FORMAT_BC2_UNORM = 0x00000064, 464 VK_FORMAT_BC2_SRGB = 0x00000065, 465 VK_FORMAT_BC3_UNORM = 0x00000066, 466 VK_FORMAT_BC3_SRGB = 0x00000067, 467 VK_FORMAT_BC4_UNORM = 0x00000068, 468 VK_FORMAT_BC4_SNORM = 0x00000069, 469 VK_FORMAT_BC5_UNORM = 0x0000006A, 470 VK_FORMAT_BC5_SNORM = 0x0000006B, 471 VK_FORMAT_BC6H_UFLOAT = 0x0000006C, 472 VK_FORMAT_BC6H_SFLOAT = 0x0000006D, 473 VK_FORMAT_BC7_UNORM = 0x0000006E, 474 VK_FORMAT_BC7_SRGB = 0x0000006F, 475 VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070, 476 VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071, 477 VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072, 478 VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073, 479 VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074, 480 VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075, 481 VK_FORMAT_EAC_R11_UNORM = 0x00000076, 482 VK_FORMAT_EAC_R11_SNORM = 0x00000077, 483 VK_FORMAT_EAC_R11G11_UNORM = 0x00000078, 484 VK_FORMAT_EAC_R11G11_SNORM = 0x00000079, 485 VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A, 486 VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B, 487 VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C, 488 VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D, 489 VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E, 490 VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F, 491 VK_FORMAT_ASTC_6x5_UNORM = 0x00000080, 492 VK_FORMAT_ASTC_6x5_SRGB = 0x00000081, 493 VK_FORMAT_ASTC_6x6_UNORM = 0x00000082, 494 VK_FORMAT_ASTC_6x6_SRGB = 0x00000083, 495 VK_FORMAT_ASTC_8x5_UNORM = 0x00000084, 496 VK_FORMAT_ASTC_8x5_SRGB = 0x00000085, 497 VK_FORMAT_ASTC_8x6_UNORM = 0x00000086, 498 VK_FORMAT_ASTC_8x6_SRGB = 0x00000087, 499 VK_FORMAT_ASTC_8x8_UNORM = 0x00000088, 500 VK_FORMAT_ASTC_8x8_SRGB = 0x00000089, 501 VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A, 502 VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B, 503 VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C, 504 VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D, 505 VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E, 506 VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F, 507 VK_FORMAT_ASTC_10x10_UNORM = 0x00000090, 508 VK_FORMAT_ASTC_10x10_SRGB = 0x00000091, 509 VK_FORMAT_ASTC_12x10_UNORM = 0x00000092, 510 VK_FORMAT_ASTC_12x10_SRGB = 0x00000093, 511 VK_FORMAT_ASTC_12x12_UNORM = 0x00000094, 512 VK_FORMAT_ASTC_12x12_SRGB = 0x00000095, 513 VK_FORMAT_B4G4R4A4_UNORM = 0x00000096, 514 VK_FORMAT_B5G5R5A1_UNORM = 0x00000097, 515 VK_FORMAT_B5G6R5_UNORM = 0x00000098, 516 VK_FORMAT_B5G6R5_USCALED = 0x00000099, 517 VK_FORMAT_B8G8R8_UNORM = 0x0000009A, 518 VK_FORMAT_B8G8R8_SNORM = 0x0000009B, 519 VK_FORMAT_B8G8R8_USCALED = 0x0000009C, 520 VK_FORMAT_B8G8R8_SSCALED = 0x0000009D, 521 VK_FORMAT_B8G8R8_UINT = 0x0000009E, 522 VK_FORMAT_B8G8R8_SINT = 0x0000009F, 523 VK_FORMAT_B8G8R8_SRGB = 0x000000A0, 524 VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1, 525 VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2, 526 VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3, 527 VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4, 528 VK_FORMAT_B8G8R8A8_UINT = 0x000000A5, 529 VK_FORMAT_B8G8R8A8_SINT = 0x000000A6, 530 VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7, 531 VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8, 532 VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9, 533 VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA, 534 VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB, 535 VK_FORMAT_B10G10R10A2_UINT = 0x000000AC, 536 VK_FORMAT_B10G10R10A2_SINT = 0x000000AD, 537} 538 539/// Shader stage enumerant 540enum VkShaderStage { 541 VK_SHADER_STAGE_VERTEX = 0x00000000, 542 VK_SHADER_STAGE_TESS_CONTROL = 0x00000001, 543 VK_SHADER_STAGE_TESS_EVALUATION = 0x00000002, 544 VK_SHADER_STAGE_GEOMETRY = 0x00000003, 545 VK_SHADER_STAGE_FRAGMENT = 0x00000004, 546 VK_SHADER_STAGE_COMPUTE = 0x00000005, 547} 548 549/// Structure type enumerant 550enum VkStructureType { 551 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 552 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, 553 VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, 554 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, 555 VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4, 556 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5, 557 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6, 558 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7, 559 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8, 560 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9, 561 VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10, 562 VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11, 563 VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12, 564 VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13, 565 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14, 566 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15, 567 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16, 568 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17, 569 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18, 570 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, 571 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20, 572 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21, 573 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22, 574 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23, 575 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24, 576 VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25, 577 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26, 578 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, 579 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28, 580 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29, 581 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30, 582 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31, 583 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32, 584 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33, 585 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34, 586 VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 35, 587 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36, 588 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37, 589 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38, 590 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39, 591 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40, 592 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41, 593 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42, 594 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43, 595 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44, 596 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45, 597 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46, 598 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47, 599 VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48, 600 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49, 601 VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 50, 602} 603 604enum VkRenderPassContents { 605 VK_RENDER_PASS_CONTENTS_INLINE = 0x00000000, 606 VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 0x00000001, 607} 608 609@lastUnused(-33) 610/// Error and return codes 611enum VkResult { 612 // Return codes for successful operation execution (positive values) 613 VK_SUCCESS = 0x00000000, 614 VK_UNSUPPORTED = 0x00000001, 615 VK_NOT_READY = 0x00000002, 616 VK_TIMEOUT = 0x00000003, 617 VK_EVENT_SET = 0x00000004, 618 VK_EVENT_RESET = 0x00000005, 619 VK_INCOMPLETE = 0x00000006, 620 621 // Error codes (negative values) 622 VK_ERROR_UNKNOWN = 0xFFFFFFFF, 623 VK_ERROR_UNAVAILABLE = 0xFFFFFFFE, 624 VK_ERROR_INITIALIZATION_FAILED = 0xFFFFFFFD, 625 VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFC, 626 VK_ERROR_OUT_OF_DEVICE_MEMORY = 0xFFFFFFFB, 627 VK_ERROR_DEVICE_ALREADY_CREATED = 0xFFFFFFFA, 628 VK_ERROR_DEVICE_LOST = 0xFFFFFFF9, 629 VK_ERROR_INVALID_POINTER = 0xFFFFFFF8, 630 VK_ERROR_INVALID_VALUE = 0xFFFFFFF7, 631 VK_ERROR_INVALID_HANDLE = 0xFFFFFFF6, 632 VK_ERROR_INVALID_ORDINAL = 0xFFFFFFF5, 633 VK_ERROR_INVALID_MEMORY_SIZE = 0xFFFFFFF4, 634 VK_ERROR_INVALID_EXTENSION = 0xFFFFFFF3, 635 VK_ERROR_INVALID_FLAGS = 0xFFFFFFF2, 636 VK_ERROR_INVALID_ALIGNMENT = 0xFFFFFFF1, 637 VK_ERROR_INVALID_FORMAT = 0xFFFFFFF0, 638 VK_ERROR_INVALID_IMAGE = 0xFFFFFFEF, 639 VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = 0xFFFFFFEE, 640 VK_ERROR_INVALID_QUEUE_TYPE = 0xFFFFFFED, 641 VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = 0xFFFFFFEC, 642 VK_ERROR_BAD_SHADER_CODE = 0xFFFFFFEB, 643 VK_ERROR_BAD_PIPELINE_DATA = 0xFFFFFFEA, 644 VK_ERROR_NOT_MAPPABLE = 0xFFFFFFE9, 645 VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFE8, 646 VK_ERROR_MEMORY_UNMAP_FAILED = 0xFFFFFFE7, 647 VK_ERROR_INCOMPATIBLE_DEVICE = 0xFFFFFFE6, 648 VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFE5, 649 VK_ERROR_INCOMPLETE_COMMAND_BUFFER = 0xFFFFFFE4, 650 VK_ERROR_BUILDING_COMMAND_BUFFER = 0xFFFFFFE3, 651 VK_ERROR_MEMORY_NOT_BOUND = 0xFFFFFFE2, 652 VK_ERROR_INCOMPATIBLE_QUEUE = 0xFFFFFFE1, 653 VK_ERROR_INVALID_LAYER = 0xFFFFFFE0, 654} 655 656 657///////////////// 658// Bitfields // 659///////////////// 660 661/// Device creation flags 662bitfield VkDeviceCreateFlags { 663 VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, 664} 665 666/// Queue capabilities 667bitfield VkQueueFlags { 668 VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations 669 VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations 670 VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations 671 VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, /// Queue supports sparse resource memory management operations 672 VK_QUEUE_EXTENDED_BIT = 0x40000000, /// Extended queue 673} 674 675/// Memory properties passed into vkAllocMemory(). 676bitfield VkMemoryPropertyFlags { 677 VK_MEMORY_PROPERTY_DEVICE_ONLY = 0x00000000, /// If otherwise stated, then allocate memory on device 678 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, /// Memory should be mappable by host 679 VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, /// Memory may not have i/o coherency so vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache 680 /// vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache 681 VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, /// Memory should not be cached by the host 682 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, /// Memory should support host write combining 683 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, /// Memory may be allocated by the driver when it is required 684} 685 686/// Memory heap flags 687bitfield VkMemoryHeapFlags { 688 VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, /// If set, heap represents host memory 689} 690 691/// Memory output flags passed to resource transition commands 692bitfield VkMemoryOutputFlags { 693 VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, /// Controls output coherency of host writes 694 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, /// Controls output coherency of generic shader writes 695 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, /// Controls output coherency of color attachment writes 696 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, /// Controls output coherency of depth/stencil attachment writes 697 VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, /// Controls output coherency of transfer operations 698} 699 700/// Memory input flags passed to resource transition commands 701bitfield VkMemoryInputFlags { 702 VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, /// Controls input coherency of host reads 703 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, /// Controls input coherency of indirect command reads 704 VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, /// Controls input coherency of index fetches 705 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, /// Controls input coherency of vertex attribute fetches 706 VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, /// Controls input coherency of uniform buffer reads 707 VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, /// Controls input coherency of generic shader reads 708 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, /// Controls input coherency of color attachment reads 709 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, /// Controls input coherency of depth/stencil attachment reads 710 VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, /// Controls input coherency of input attachment reads 711 VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, /// Controls input coherency of transfer operations 712} 713 714/// Buffer usage flags 715bitfield VkBufferUsageFlags { 716 VK_BUFFER_USAGE_GENERAL = 0x00000000, /// No special usage 717 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations 718 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations 719 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO 720 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, /// Can be used as IBO 721 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, /// Can be used as UBO 722 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, /// Can be used as SSBO 723 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, /// Can be used as source of fixed function index fetch (index buffer) 724 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, /// Can be used as source of fixed function vertex fetch (VBO) 725 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, /// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) 726} 727 728/// Buffer creation flags 729bitfield VkBufferCreateFlags { 730 VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001, /// Buffer should support sparse backing 731 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Buffer should support sparse backing with partial residency 732 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers 733} 734 735/// Shader stage flags 736bitfield VkShaderStageFlags { 737 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 738 VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, 739 VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004, 740 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 741 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 742 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 743 744 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 745} 746 747/// Image usage flags 748bitfield VkImageUsageFlags { 749 VK_IMAGE_USAGE_GENERAL = 0x00000000, /// No special usage 750 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations 751 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations 752 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) 753 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, /// Can be used as storage image (STORAGE_IMAGE descriptor type) 754 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, /// Can be used as framebuffer color attachment 755 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020, /// Can be used as framebuffer depth/stencil attachment 756 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, /// Image data not needed outside of rendering 757 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, /// Can be used as framebuffer input attachment 758} 759 760/// Image creation flags 761bitfield VkImageCreateFlags { 762 VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, /// Image should support sparse backing 763 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Image should support sparse backing with partial residency 764 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images 765 VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, 766 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, /// Allows image views to have different format than the base image 767 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, /// Allows creating image views with cube type from the created image 768} 769 770/// Framebuffer attachment view creation flags 771bitfield VkAttachmentViewCreateFlags { 772 VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, 773 VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, 774} 775 776/// Pipeline creation flags 777bitfield VkPipelineCreateFlags { 778 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 779 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 780 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 781} 782 783/// Channel flags 784bitfield VkChannelFlags { 785 VK_CHANNEL_R_BIT = 0x00000001, 786 VK_CHANNEL_G_BIT = 0x00000002, 787 VK_CHANNEL_B_BIT = 0x00000004, 788 VK_CHANNEL_A_BIT = 0x00000008, 789} 790 791/// Fence creation flags 792bitfield VkFenceCreateFlags { 793 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 794} 795 796/// Semaphore creation flags 797bitfield VkSemaphoreCreateFlags { 798} 799 800/// Format capability flags 801bitfield VkFormatFeatureFlags { 802 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) 803 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, /// Format can be used for storage images (STORAGE_IMAGE descriptor type) 804 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, /// Format supports atomic operations in case it's used for storage images 805 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, /// Format can be used for uniform texel buffers (TBOs) 806 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, /// Format can be used for storage texel buffers (IBOs) 807 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, /// Format supports atomic operations in case it's used for storage texel buffers 808 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, /// Format can be used for vertex buffers (VBOs) 809 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, /// Format can be used for color attachment images 810 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, /// Format supports blending in case it's used for color attachment images 811 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, /// Format can be used for depth/stencil attachment images 812 VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400, /// Format can be used as the source or destination of format converting blits 813} 814 815/// Query control flags 816bitfield VkQueryControlFlags { 817 VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, /// Allow conservative results to be collected by the query 818} 819 820/// Query result flags 821bitfield VkQueryResultFlags { 822 VK_QUERY_RESULT_DEFAULT = 0x00000000, /// Results of the queries are immediately written to the destination buffer as 32-bit values 823 VK_QUERY_RESULT_64_BIT = 0x00000001, /// Results of the queries are written to the destination buffer as 64-bit values 824 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, /// Results of the queries are waited on before proceeding with the result copy 825 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, /// Besides the results of the query, the availability of the results is also written 826 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, /// Copy the partial results of the query even if the final results aren't available 827} 828 829/// Shader module creation flags 830bitfield VkShaderModuleCreateFlags { 831} 832 833/// Shader creation flags 834bitfield VkShaderCreateFlags { 835} 836 837/// Event creation flags 838bitfield VkEventCreateFlags { 839} 840 841/// Command buffer creation flags 842bitfield VkCmdBufferCreateFlags { 843} 844 845/// Command buffer optimization flags 846bitfield VkCmdBufferOptimizeFlags { 847 VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, 848 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, 849 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, 850 VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, 851 VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, /// Only one call to the secondary command buffer will exist at any given time 852} 853 854/// Pipeline statistics flags 855bitfield VkQueryPipelineStatisticFlags { 856 VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, /// Optional 857 VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, /// Optional 858 VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, /// Optional 859 VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, /// Optional 860 VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, /// Optional 861 VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, /// Optional 862 VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, /// Optional 863 VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, /// Optional 864 VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, /// Optional 865 VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, /// Optional 866 VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, /// Optional 867} 868 869/// Memory mapping flags 870bitfield VkMemoryMapFlags { 871} 872 873/// Bitfield of image aspects 874bitfield VkImageAspectFlags { 875 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 876 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 877 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 878 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 879} 880 881/// Sparse memory bind flags 882bitfield VkSparseMemoryBindFlags { 883 VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, /// Replicate the first 64 KiB memory block to the entire bind rage 884} 885 886/// Sparse image memory requirements flags 887bitfield VkSparseImageFormatFlags { 888 VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices 889 VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels. 890 VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size 891} 892 893/// Pipeline stages 894bitfield VkPipelineStageFlags { 895 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, /// Before subsequent commands are processed 896 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, /// Draw/DispatchIndirect command fetch 897 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, /// Vertex/index fetch 898 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, /// Vertex shading 899 VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT = 0x00000010, /// Tessellation control shading 900 VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT = 0x00000020, /// Tessellation evaluation shading 901 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, /// Geometry shading 902 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, /// Fragment shading 903 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, /// Early fragment (depth/stencil) tests 904 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, /// Late fragment (depth/stencil) tests 905 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, /// Color attachment writes 906 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, /// Compute shading 907 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, /// Transfer/copy operations 908 VK_PIPELINE_STAGE_TRANSITION_BIT = 0x00002000, /// Resource transition commands 909 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, /// Indicates host (CPU) is a source/sink of the dependency 910 911 VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, /// All stages of the graphics pipeline 912 VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF, /// All graphics, compute, copy, and transition commands 913} 914 915/// Subpass description flags 916bitfield VkSubpassDescriptionFlags { 917 VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, 918} 919 920/// Command pool creation flags 921bitfield VkCmdPoolCreateFlags { 922 VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime 923 VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually 924} 925 926/// Command pool reset flags 927bitfield VkCmdPoolResetFlags { 928 VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001, /// Release resources owned by the pool 929} 930 931bitfield VkCmdBufferResetFlags { 932 VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001, /// Release resources owned by the buffer 933} 934 935 936////////////////// 937// Structures // 938////////////////// 939 940class VkOffset2D { 941 s32 x 942 s32 y 943} 944 945class VkOffset3D { 946 s32 x 947 s32 y 948 s32 z 949} 950 951class VkExtent2D { 952 s32 width 953 s32 height 954} 955 956class VkExtent3D { 957 s32 width 958 s32 height 959 s32 depth 960} 961 962class VkViewport { 963 f32 originX 964 f32 originY 965 f32 width 966 f32 height 967 f32 minDepth 968 f32 maxDepth 969} 970 971class VkRect2D { 972 VkOffset2D offset 973 VkExtent2D extent 974} 975 976class VkRect3D { 977 VkOffset3D offset 978 VkExtent3D extent 979} 980 981class VkChannelMapping { 982 VkChannelSwizzle r 983 VkChannelSwizzle g 984 VkChannelSwizzle b 985 VkChannelSwizzle a 986} 987 988class VkPhysicalDeviceProperties { 989 u32 apiVersion 990 u32 driverVersion 991 u32 vendorId 992 u32 deviceId 993 VkPhysicalDeviceType deviceType 994 char[VK_MAX_PHYSICAL_DEVICE_NAME] deviceName 995 u8[VK_UUID_LENGTH] pipelineCacheUUID 996} 997 998class VkExtensionProperties { 999 char[VK_MAX_EXTENSION_NAME] extName /// extension name 1000 u32 specVersion /// version of the extension specification implemented 1001} 1002 1003class VkLayerProperties { 1004 char[VK_MAX_EXTENSION_NAME] layerName /// layer name 1005 u32 specVersion /// version of the layer specification implemented 1006 u32 implVersion /// build or release version of the layer's library 1007 const char*[VK_MAX_DESCRIPTION] description /// Free-form description of the layer 1008} 1009 1010class VkApplicationInfo { 1011 VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO 1012 const void* pNext /// Next structure in chain 1013 const char* pAppName 1014 u32 appVersion 1015 const char* pEngineName 1016 u32 engineVersion 1017 u32 apiVersion 1018} 1019 1020class VkAllocCallbacks { 1021 void* pUserData 1022 PFN_vkAllocFunction pfnAlloc 1023 PFN_vkFreeFunction pfnFree 1024} 1025 1026class VkDeviceQueueCreateInfo { 1027 u32 queueFamilyIndex 1028 u32 queueCount 1029} 1030 1031class VkDeviceCreateInfo { 1032 VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO 1033 const void* pNext /// Pointer to next structure 1034 u32 queueRecordCount 1035 const VkDeviceQueueCreateInfo* pRequestedQueues 1036 u32 layerCount 1037 const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled 1038 u32 extensionCount 1039 const char* const* ppEnabledExtensionNames 1040 const VkPhysicalDeviceFeatures* pEnabledFeatures 1041 VkDeviceCreateFlags flags /// Device creation flags 1042} 1043 1044class VkInstanceCreateInfo { 1045 VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO 1046 const void* pNext /// Pointer to next structure 1047 const VkApplicationInfo* pAppInfo 1048 const VkAllocCallbacks* pAllocCb 1049 u32 layerCount 1050 const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled 1051 u32 extensionCount 1052 const char* const* ppEnabledExtensionNames /// Extension names to be enabled 1053} 1054 1055class VkPhysicalDeviceQueueProperties { 1056 VkQueueFlags queueFlags /// Queue flags 1057 u32 queueCount 1058 platform.VkBool32 supportsTimestamps 1059} 1060 1061class VkPhysicalDeviceMemoryProperties { 1062 u32 memoryTypeCount 1063 VkMemoryType[VK_MAX_MEMORY_TYPES] memoryTypes 1064 u32 memoryHeapCount 1065 VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps 1066} 1067 1068class VkMemoryAllocInfo { 1069 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO 1070 const void* pNext /// Pointer to next structure 1071 platform.VkDeviceSize allocationSize /// Size of memory allocation 1072 u32 memoryTypeIndex /// Index of the of the memory type to allocate from 1073} 1074 1075class VkMemoryRequirements { 1076 platform.VkDeviceSize size /// Specified in bytes 1077 platform.VkDeviceSize alignment /// Specified in bytes 1078 u32 memoryTypeBits /// Bitfield of the allowed memory type indices into memoryTypes[] for this object 1079} 1080 1081class VkSparseImageFormatProperties { 1082 VkImageAspect aspect 1083 VkExtent3D imageGranularity 1084 VkSparseImageFormatFlags flags 1085} 1086 1087class VkSparseImageMemoryRequirements { 1088 VkSparseImageFormatProperties formatProps 1089 u32 imageMipTailStartLOD 1090 platform.VkDeviceSize imageMipTailSize /// Specified in bytes, must be a multiple of image block size / alignment 1091 platform.VkDeviceSize imageMipTailOffset /// Specified in bytes, must be a multiple of image block size / alignment 1092 platform.VkDeviceSize imageMipTailStride /// Specified in bytes, must be a multiple of image block size / alignment 1093} 1094 1095class VkMemoryType { 1096 VkMemoryPropertyFlags propertyFlags /// Memory properties of this memory type 1097 u32 heapIndex /// Index of the memory heap allocations of this memory type are taken from 1098} 1099 1100class VkMemoryHeap { 1101 platform.VkDeviceSize size /// Available memory in the heap 1102 VkMemoryHeapFlags flags /// Flags for the heap 1103} 1104 1105class VkMappedMemoryRange { 1106 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE 1107 const void* pNext /// Pointer to next structure 1108 VkDeviceMemory mem /// Mapped memory object 1109 platform.VkDeviceSize offset /// Offset within the mapped memory the range starts from 1110 platform.VkDeviceSize size /// Size of the range within the mapped memory 1111} 1112 1113class VkFormatProperties { 1114 VkFormatFeatureFlags linearTilingFeatures /// Format features in case of linear tiling 1115 VkFormatFeatureFlags optimalTilingFeatures /// Format features in case of optimal tiling 1116} 1117 1118class VkImageFormatProperties { 1119 u64 maxResourceSize /// max size (in bytes) of this resource type 1120 u32 maxSamples /// max sample count for this resource type 1121} 1122 1123class VkDescriptorInfo { 1124 VkBufferView bufferView /// Buffer view to write to the descriptor (in case it's a buffer descriptor, otherwise should be VK_NULL_HANDLE) 1125 VkSampler sampler /// Sampler to write to the descriptor (in case it's a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor, otherwise should be VK_NULL_HANDLE) 1126 VkImageView imageView /// Image view to write to the descriptor (in case it's a SAMPLED_IMAGE, STORAGE_IMAGE, or COMBINED_IMAGE_SAMPLER descriptor, otherwise should be VK_NULL_HANDLE) 1127 VkAttachmentView attachmentView /// Input attachment view to write to the descriptor (in case it's a INPUT_ATTACHMENT descriptor, otherwise should be VK_NULL_HANDLE) 1128 VkImageLayout imageLayout /// Layout the image is expected to be in when accessed using this descriptor (only used if imageView or attachmentView is not VK_NULL_HANDLE) 1129} 1130 1131class VkWriteDescriptorSet { 1132 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET 1133 const void* pNext /// Pointer to next structure 1134 VkDescriptorSet destSet /// Destination descriptor set 1135 u32 destBinding /// Binding within the destination descriptor set to write 1136 u32 destArrayElement /// Array element within the destination binding to write 1137 u32 count /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>) 1138 VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used) 1139 const VkDescriptorInfo* pDescriptors /// Array of info structures describing the descriptors to write 1140} 1141 1142class VkCopyDescriptorSet { 1143 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET 1144 const void* pNext /// Pointer to next structure 1145 VkDescriptorSet srcSet /// Source descriptor set 1146 u32 srcBinding /// Binding within the source descriptor set to copy from 1147 u32 srcArrayElement /// Array element within the source binding to copy from 1148 VkDescriptorSet destSet /// Destination descriptor set 1149 u32 destBinding /// Binding within the destination descriptor set to copy to 1150 u32 destArrayElement /// Array element within the destination binding to copy to 1151 u32 count /// Number of descriptors to copy 1152} 1153 1154class VkBufferCreateInfo { 1155 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO 1156 const void* pNext /// Pointer to next structure. 1157 platform.VkDeviceSize size /// Specified in bytes 1158 VkBufferUsageFlags usage /// Buffer usage flags 1159 VkBufferCreateFlags flags /// Buffer creation flags 1160 VkSharingMode sharingMode 1161 u32 queueFamilyCount 1162 const u32* pQueueFamilyIndices 1163} 1164 1165class VkBufferViewCreateInfo { 1166 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO 1167 const void* pNext /// Pointer to next structure. 1168 VkBuffer buffer 1169 VkBufferViewType viewType 1170 VkFormat format /// Optionally specifies format of elements 1171 platform.VkDeviceSize offset /// Specified in bytes 1172 platform.VkDeviceSize range /// View size specified in bytes 1173} 1174 1175class VkImageSubresource { 1176 VkImageAspect aspect 1177 u32 mipLevel 1178 u32 arraySlice 1179} 1180 1181class VkImageSubresourceRange { 1182 VkImageAspect aspect 1183 u32 baseMipLevel 1184 u32 mipLevels 1185 u32 baseArraySlice 1186 u32 arraySize 1187} 1188 1189class VkMemoryBarrier { 1190 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER 1191 const void* pNext /// Pointer to next structure. 1192 VkMemoryOutputFlags outputMask /// Outputs the barrier should sync 1193 VkMemoryInputFlags inputMask /// Inputs the barrier should sync to 1194} 1195 1196class VkBufferMemoryBarrier { 1197 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER 1198 const void* pNext /// Pointer to next structure. 1199 VkMemoryOutputFlags outputMask /// Outputs the barrier should sync 1200 VkMemoryInputFlags inputMask /// Inputs the barrier should sync to 1201 u32 srcQueueFamilyIndex /// Queue family to transition ownership from 1202 u32 destQueueFamilyIndex /// Queue family to transition ownership to 1203 VkBuffer buffer /// Buffer to sync 1204 platform.VkDeviceSize offset /// Offset within the buffer to sync 1205 platform.VkDeviceSize size /// Amount of bytes to sync 1206} 1207 1208class VkImageMemoryBarrier { 1209 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER 1210 const void* pNext /// Pointer to next structure. 1211 VkMemoryOutputFlags outputMask /// Outputs the barrier should sync 1212 VkMemoryInputFlags inputMask /// Inputs the barrier should sync to 1213 VkImageLayout oldLayout /// Current layout of the image 1214 VkImageLayout newLayout /// New layout to transition the image to 1215 u32 srcQueueFamilyIndex /// Queue family to transition ownership from 1216 u32 destQueueFamilyIndex /// Queue family to transition ownership to 1217 VkImage image /// Image to sync 1218 VkImageSubresourceRange subresourceRange /// Subresource range to sync 1219} 1220 1221class VkImageCreateInfo { 1222 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO 1223 const void* pNext /// Pointer to next structure. 1224 VkImageType imageType 1225 VkFormat format 1226 VkExtent3D extent 1227 u32 mipLevels 1228 u32 arraySize 1229 u32 samples 1230 VkImageTiling tiling 1231 VkImageUsageFlags usage /// Image usage flags 1232 VkImageCreateFlags flags /// Image creation flags 1233 VkSharingMode sharingMode /// Cross-queue-family sharing mode 1234 u32 queueFamilyCount /// Number of queue families to share across 1235 const u32* pQueueFamilyIndices /// Array of queue family indices to share across 1236} 1237 1238class VkSubresourceLayout { 1239 platform.VkDeviceSize offset /// Specified in bytes 1240 platform.VkDeviceSize size /// Specified in bytes 1241 platform.VkDeviceSize rowPitch /// Specified in bytes 1242 platform.VkDeviceSize depthPitch /// Specified in bytes 1243} 1244 1245class VkImageViewCreateInfo { 1246 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO 1247 const void* pNext /// Pointer to next structure 1248 VkImage image 1249 VkImageViewType viewType 1250 VkFormat format 1251 VkChannelMapping channels 1252 VkImageSubresourceRange subresourceRange 1253} 1254 1255class VkAttachmentViewCreateInfo { 1256 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO 1257 const void* pNext /// Pointer to next structure 1258 VkImage image 1259 VkFormat format 1260 u32 mipLevel 1261 u32 baseArraySlice 1262 u32 arraySize 1263 VkAttachmentViewCreateFlags flags /// Framebuffer attachment view flags 1264} 1265 1266class VkAttachmentBindInfo { 1267 VkAttachmentView view 1268 VkImageLayout layout 1269} 1270 1271class VkBufferCopy { 1272 platform.VkDeviceSize srcOffset /// Specified in bytes 1273 platform.VkDeviceSize destOffset /// Specified in bytes 1274 platform.VkDeviceSize copySize /// Specified in bytes 1275} 1276 1277class VkSparseMemoryBindInfo { 1278 platform.VkDeviceSize offset /// Specified in bytes 1279 platform.VkDeviceSize memOffset /// Specified in bytes 1280 VkDeviceMemory mem 1281 VkSparseMemoryBindFlags flags 1282} 1283 1284class VkSparseImageMemoryBindInfo { 1285 VkImageSubresource subresource 1286 VkOffset3D offset 1287 VkExtent3D extent 1288 platform.VkDeviceSize memOffset /// Specified in bytes 1289 VkDeviceMemory mem 1290 VkSparseMemoryBindFlags flags 1291} 1292 1293class VkImageCopy { 1294 VkImageSubresource srcSubresource 1295 VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images 1296 VkImageSubresource destSubresource 1297 VkOffset3D destOffset /// Specified in pixels for both compressed and uncompressed images 1298 VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images 1299} 1300 1301class VkImageBlit { 1302 VkImageSubresource srcSubresource 1303 VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images 1304 VkExtent3D srcExtent /// Specified in pixels for both compressed and uncompressed images 1305 VkImageSubresource destSubresource 1306 VkOffset3D destOffset /// Specified in pixels for both compressed and uncompressed images 1307 VkExtent3D destExtent /// Specified in pixels for both compressed and uncompressed images 1308} 1309 1310class VkBufferImageCopy { 1311 platform.VkDeviceSize bufferOffset /// Specified in bytes 1312 u32 bufferRowLength /// Specified in texels 1313 u32 bufferImageHeight 1314 VkImageSubresource imageSubresource 1315 VkOffset3D imageOffset /// Specified in pixels for both compressed and uncompressed images 1316 VkExtent3D imageExtent /// Specified in pixels for both compressed and uncompressed images 1317} 1318 1319class VkImageResolve { 1320 VkImageSubresource srcSubresource 1321 VkOffset3D srcOffset 1322 VkImageSubresource destSubresource 1323 VkOffset3D destOffset 1324 VkExtent3D extent 1325} 1326 1327class VkShaderModuleCreateInfo { 1328 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO 1329 const void* pNext /// Pointer to next structure 1330 platform.size_t codeSize /// Specified in bytes 1331 const void* pCode /// Binary code of size codeSize 1332 VkShaderModuleCreateFlags flags /// Reserved 1333} 1334 1335class VkShaderCreateInfo { 1336 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO 1337 const void* pNext /// Pointer to next structure 1338 VkShaderModule module /// Module containing entry point 1339 const char* pName /// Null-terminated entry point name 1340 VkShaderCreateFlags flags /// Reserved 1341} 1342 1343class VkDescriptorSetLayoutBinding { 1344 VkDescriptorType descriptorType /// Type of the descriptors in this binding 1345 u32 arraySize /// Number of descriptors in this binding 1346 VkShaderStageFlags stageFlags /// Shader stages this binding is visible to 1347 const VkSampler* pImmutableSamplers /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements) 1348} 1349 1350class VkDescriptorSetLayoutCreateInfo { 1351 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO 1352 const void* pNext /// Pointer to next structure 1353 u32 count /// Number of bindings in the descriptor set layout 1354 const VkDescriptorSetLayoutBinding* pBinding /// Array of descriptor set layout bindings 1355} 1356 1357class VkDescriptorTypeCount { 1358 VkDescriptorType type 1359 u32 count 1360} 1361 1362class VkDescriptorPoolCreateInfo { 1363 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO 1364 const void* pNext /// Pointer to next structure 1365 u32 count 1366 const VkDescriptorTypeCount* pTypeCount 1367} 1368 1369class VkSpecializationMapEntry { 1370 u32 constantId /// The SpecConstant ID specified in the BIL 1371 platform.size_t size /// Size in bytes of the SpecConstant 1372 u32 offset /// Offset of the value in the data block 1373} 1374 1375class VkSpecializationInfo { 1376 u32 mapEntryCount /// Number of entries in the map 1377 const VkSpecializationMapEntry* pMap /// Array of map entries 1378 platform.size_t dataSize /// Size in bytes of pData 1379 const void* pData /// Pointer to SpecConstant data 1380} 1381 1382class VkPipelineShaderStageCreateInfo { 1383 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO 1384 const void* pNext /// Pointer to next structure 1385 VkShaderStage stage 1386 VkShader shader 1387 const VkSpecializationInfo* pSpecializationInfo 1388} 1389 1390class VkComputePipelineCreateInfo { 1391 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO 1392 const void* pNext /// Pointer to next structure 1393 VkPipelineShaderStageCreateInfo cs 1394 VkPipelineCreateFlags flags /// Pipeline creation flags 1395 VkPipelineLayout layout /// Interface layout of the pipeline 1396 VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of 1397 s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of 1398} 1399 1400class VkVertexInputBindingDescription { 1401 u32 binding /// Vertex buffer binding id 1402 u32 strideInBytes /// Distance between vertices in bytes (0 = no advancement) 1403 VkVertexInputStepRate stepRate /// Rate at which binding is incremented 1404} 1405 1406class VkVertexInputAttributeDescription { 1407 u32 location /// location of the shader vertex attrib 1408 u32 binding /// Vertex buffer binding id 1409 VkFormat format /// format of source data 1410 u32 offsetInBytes /// Offset of first element in bytes from base of vertex 1411} 1412 1413class VkPipelineVertexInputStateCreateInfo { 1414 VkStructureType sType /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO 1415 const void* pNext /// Pointer to next structure 1416 u32 bindingCount /// number of bindings 1417 const VkVertexInputBindingDescription* pVertexBindingDescriptions 1418 u32 attributeCount /// number of attributes 1419 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions 1420} 1421 1422class VkPipelineInputAssemblyStateCreateInfo { 1423 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO 1424 const void* pNext /// Pointer to next structure 1425 VkPrimitiveTopology topology 1426 platform.VkBool32 primitiveRestartEnable 1427} 1428 1429class VkPipelineTessellationStateCreateInfo { 1430 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO 1431 const void* pNext /// Pointer to next structure 1432 u32 patchControlPoints 1433} 1434 1435class VkPipelineViewportStateCreateInfo { 1436 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO 1437 const void* pNext /// Pointer to next structure 1438 u32 viewportCount 1439} 1440 1441class VkPipelineRasterStateCreateInfo { 1442 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO 1443 const void* pNext /// Pointer to next structure 1444 platform.VkBool32 depthClipEnable 1445 platform.VkBool32 rasterizerDiscardEnable 1446 VkFillMode fillMode /// optional (GL45) 1447 VkCullMode cullMode 1448 VkFrontFace frontFace 1449} 1450 1451class VkPipelineMultisampleStateCreateInfo { 1452 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO 1453 const void* pNext /// Pointer to next structure 1454 u32 rasterSamples /// Number of samples used for rasterization 1455 platform.VkBool32 sampleShadingEnable /// optional (GL45) 1456 f32 minSampleShading /// optional (GL45) 1457 platform.VkSampleMask sampleMask 1458} 1459 1460class VkPipelineColorBlendAttachmentState { 1461 platform.VkBool32 blendEnable 1462 VkBlend srcBlendColor 1463 VkBlend destBlendColor 1464 VkBlendOp blendOpColor 1465 VkBlend srcBlendAlpha 1466 VkBlend destBlendAlpha 1467 VkBlendOp blendOpAlpha 1468 VkChannelFlags channelWriteMask 1469} 1470 1471class VkPipelineColorBlendStateCreateInfo { 1472 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO 1473 const void* pNext /// Pointer to next structure 1474 platform.VkBool32 alphaToCoverageEnable 1475 platform.VkBool32 logicOpEnable 1476 VkLogicOp logicOp 1477 u32 attachmentCount /// # of pAttachments 1478 const VkPipelineColorBlendAttachmentState* pAttachments 1479} 1480 1481class VkStencilOpState { 1482 VkStencilOp stencilFailOp 1483 VkStencilOp stencilPassOp 1484 VkStencilOp stencilDepthFailOp 1485 VkCompareOp stencilCompareOp 1486} 1487 1488class VkPipelineDepthStencilStateCreateInfo { 1489 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO 1490 const void* pNext /// Pointer to next structure 1491 platform.VkBool32 depthTestEnable 1492 platform.VkBool32 depthWriteEnable 1493 VkCompareOp depthCompareOp 1494 platform.VkBool32 depthBoundsEnable /// optional (depth_bounds_test) 1495 platform.VkBool32 stencilTestEnable 1496 VkStencilOpState front 1497 VkStencilOpState back 1498} 1499 1500class VkGraphicsPipelineCreateInfo { 1501 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO 1502 const void* pNext /// Pointer to next structure 1503 u32 stageCount 1504 const VkPipelineShaderStageCreateInfo* pStages /// One entry for each active shader stage 1505 const VkPipelineVertexInputStateCreateInfo* pVertexInputState 1506 const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState 1507 const VkPipelineTessellationStateCreateInfo* pTessellationState 1508 const VkPipelineViewportStateCreateInfo* pViewportState 1509 const VkPipelineRasterStateCreateInfo* pRasterState 1510 const VkPipelineMultisampleStateCreateInfo* pMultisampleState 1511 const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState 1512 const VkPipelineColorBlendStateCreateInfo* pColorBlendState 1513 VkPipelineCreateFlags flags /// Pipeline creation flags 1514 VkPipelineLayout layout /// Interface layout of the pipeline 1515 VkRenderPass renderPass 1516 u32 subpass 1517 VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of 1518 s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of 1519} 1520 1521class VkPipelineCacheCreateInfo { 1522 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO 1523 const void* pNext /// Pointer to next structure 1524 platform.size_t initialSize /// Size of initial data to populate cache, in bytes 1525 const void* initialData /// Initial data to populate cache 1526 platform.size_t maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound. 1527} 1528 1529class VkPushConstantRange { 1530 VkShaderStageFlags stageFlags /// Which stages use the range 1531 u32 start /// Start of the range, in bytes 1532 u32 length /// Length of the range, in bytes 1533} 1534 1535class VkPipelineLayoutCreateInfo { 1536 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO 1537 const void* pNext /// Pointer to next structure 1538 u32 descriptorSetCount /// Number of descriptor sets interfaced by the pipeline 1539 const VkDescriptorSetLayout* pSetLayouts /// Array of <setCount> number of descriptor set layout objects defining the layout of the 1540 u32 pushConstantRangeCount /// Number of push-constant ranges used by the pipeline 1541 const VkPushConstantRange* pPushConstantRanges /// Array of pushConstantRangeCount number of ranges used by various shader stages 1542} 1543 1544class VkSamplerCreateInfo { 1545 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO 1546 const void* pNext /// Pointer to next structure 1547 VkTexFilter magFilter /// Filter mode for magnification 1548 VkTexFilter minFilter /// Filter mode for minifiation 1549 VkTexMipmapMode mipMode /// Mipmap selection mode 1550 VkTexAddress addressU 1551 VkTexAddress addressV 1552 VkTexAddress addressW 1553 f32 mipLodBias 1554 f32 maxAnisotropy 1555 platform.VkBool32 compareEnable 1556 VkCompareOp compareOp 1557 f32 minLod 1558 f32 maxLod 1559 VkBorderColor borderColor 1560} 1561 1562class VkDynamicViewportStateCreateInfo { 1563 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO 1564 const void* pNext /// Pointer to next structure 1565 u32 viewportAndScissorCount /// number of entries in pViewports and pScissors 1566 const VkViewport* pViewports 1567 const VkRect2D* pScissors 1568} 1569 1570class VkDynamicRasterStateCreateInfo { 1571 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO 1572 const void* pNext /// Pointer to next structure 1573 f32 depthBias 1574 f32 depthBiasClamp 1575 f32 slopeScaledDepthBias 1576 f32 lineWidth /// optional (GL45) - Width of lines 1577} 1578 1579class VkDynamicColorBlendStateCreateInfo { 1580 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO 1581 const void* pNext /// Pointer to next structure 1582 f32[4] blendConst 1583} 1584 1585class VkDynamicDepthStencilStateCreateInfo { 1586 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO 1587 const void* pNext /// Pointer to next structure 1588 f32 minDepthBounds /// optional (depth_bounds_test) 1589 f32 maxDepthBounds /// optional (depth_bounds_test) 1590 u32 stencilReadMask 1591 u32 stencilWriteMask 1592 u32 stencilFrontRef 1593 u32 stencilBackRef 1594} 1595 1596class VkCmdPoolCreateInfo { 1597 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO 1598 const void* pNext /// Pointer to next structure 1599 u32 queueFamilyIndex 1600 VkCmdPoolCreateFlags flags /// Command pool creation flags 1601} 1602 1603class VkCmdBufferCreateInfo { 1604 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO 1605 const void* pNext /// Pointer to next structure 1606 VkCmdPool cmdPool 1607 VkCmdBufferLevel level 1608 VkCmdBufferCreateFlags flags /// Command buffer creation flags 1609} 1610 1611class VkCmdBufferBeginInfo { 1612 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO 1613 const void* pNext /// Pointer to next structure 1614 VkCmdBufferOptimizeFlags flags /// Command buffer optimization flags 1615 VkRenderPass renderPass /// Render pass for secondary command buffers 1616 VkFramebuffer framebuffer /// Framebuffer for secondary command buffers 1617} 1618 1619class VkRenderPassBeginInfo { 1620 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO 1621 const void* pNext /// Pointer to next structure 1622 VkRenderPass renderPass 1623 VkFramebuffer framebuffer 1624 VkRect2D renderArea 1625 u32 attachmentCount 1626 const VkClearValue* pAttachmentClearValues 1627} 1628 1629@union 1630/// Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared. 1631class VkClearColorValue { 1632 f32[4] f32 1633 s32[4] s32 1634 u32[4] u32 1635} 1636 1637class VkClearDepthStencilValue { 1638 f32 depth 1639 u32 stencil 1640} 1641 1642@union 1643/// Union allowing specification of color, depth, and stencil color values. Actual value selected is based on attachment being cleared. 1644class VkClearValue { 1645 VkClearColorValue color 1646 VkClearDepthStencilValue ds 1647} 1648 1649class VkAttachmentDescription { 1650 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION 1651 const void* pNext /// Pointer to next structure 1652 VkFormat format 1653 u32 samples 1654 VkAttachmentLoadOp loadOp /// Load op for color or depth data 1655 VkAttachmentStoreOp storeOp /// Store op for color or depth data 1656 VkAttachmentLoadOp stencilLoadOp /// Load op for stencil data 1657 VkAttachmentStoreOp stencilStoreOp /// Store op for stencil data 1658 VkImageLayout initialLayout 1659 VkImageLayout finalLayout 1660} 1661 1662class VkAttachmentReference { 1663 u32 attachment 1664 VkImageLayout layout 1665} 1666 1667class VkSubpassDescription { 1668 VkStructureType sType /// Must be VK_STRUCTURE_SUBPASS_DESCRIPTION 1669 const void* pNext /// Pointer to next structure 1670 VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now 1671 VkSubpassDescriptionFlags flags 1672 u32 inputCount 1673 const VkAttachmentReference* inputAttachments 1674 u32 colorCount 1675 const VkAttachmentReference* colorAttachments 1676 const VkAttachmentReference* resolveAttachments 1677 VkAttachmentReference depthStencilAttachment 1678 u32 preserveCount 1679 const VkAttachmentReference* preserveAttachments 1680} 1681 1682class VkSubpassDependency { 1683 VkStructureType sType /// Must be VK_STRUCTURE_SUBPASS_DEPENDENCY 1684 const void* pNext /// Pointer to next structure 1685 u32 srcSubpass 1686 u32 destSubpass 1687 VkPipelineStageFlags srcStageMask 1688 VkPipelineStageFlags destStageMask 1689 VkMemoryOutputFlags outputMask 1690 VkMemoryInputFlags inputMask 1691 platform.VkBool32 byRegion 1692} 1693 1694class VkRenderPassCreateInfo { 1695 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO 1696 const void* pNext /// Pointer to next structure 1697 u32 attachmentCount 1698 const VkAttachmentDescription* pAttachments 1699 u32 subpassCount 1700 const VkSubpassDescription* pSubpasses 1701 u32 dependencyCount 1702 const VkSubpassDependency* pDependencies 1703} 1704 1705class VkEventCreateInfo { 1706 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO 1707 const void* pNext /// Pointer to next structure 1708 VkEventCreateFlags flags /// Event creation flags 1709} 1710 1711class VkFenceCreateInfo { 1712 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO 1713 const void* pNext /// Pointer to next structure 1714 VkFenceCreateFlags flags /// Fence creation flags 1715} 1716 1717class VkPhysicalDeviceFeatures { 1718 platform.VkBool32 robustBufferAccess /// out of bounds buffer accesses are well defined 1719 platform.VkBool32 fullDrawIndexUint32 /// full 32-bit range of indices for indexed draw calls 1720 platform.VkBool32 imageCubeArray /// image views which are arrays of cube maps 1721 platform.VkBool32 independentBlend /// blending operations are controlled per-attachment 1722 platform.VkBool32 geometryShader /// geometry stage 1723 platform.VkBool32 tessellationShader /// tessellation control and evaluation stage 1724 platform.VkBool32 sampleRateShading /// per-sample shading and interpolation 1725 platform.VkBool32 dualSourceBlend /// blend operations which take two sources 1726 platform.VkBool32 logicOp /// logic operations 1727 platform.VkBool32 instancedDrawIndirect /// multi draw indirect 1728 platform.VkBool32 depthClip /// depth clipping 1729 platform.VkBool32 depthBiasClamp /// depth bias clamping 1730 platform.VkBool32 fillModeNonSolid /// point and wireframe fill modes 1731 platform.VkBool32 depthBounds /// depth bounds test 1732 platform.VkBool32 wideLines /// lines with width greater than 1 1733 platform.VkBool32 largePoints /// points with size greater than 1 1734 platform.VkBool32 textureCompressionETC2 /// ETC texture compression formats 1735 platform.VkBool32 textureCompressionASTC_LDR /// ASTC LDR texture compression formats 1736 platform.VkBool32 textureCompressionBC /// BC1-7 texture compressed formats 1737 platform.VkBool32 pipelineStatisticsQuery /// pipeline statistics query 1738 platform.VkBool32 vertexSideEffects /// storage buffers and images in vertex stage 1739 platform.VkBool32 tessellationSideEffects /// storage buffers and images in tessellation stage 1740 platform.VkBool32 geometrySideEffects /// storage buffers and images in geometry stage 1741 platform.VkBool32 fragmentSideEffects /// storage buffers and images in fragment stage 1742 platform.VkBool32 shaderTessellationPointSize /// tessellation stage can export point size 1743 platform.VkBool32 shaderGeometryPointSize /// geometry stage can export point size 1744 platform.VkBool32 shaderTextureGatherExtended /// texture gather with run-time values and independent offsets 1745 platform.VkBool32 shaderStorageImageExtendedFormats /// the extended set of formats can be used for storage images 1746 platform.VkBool32 shaderStorageImageMultisample /// multisample images can be used for storage images 1747 platform.VkBool32 shaderStorageBufferArrayConstantIndexing /// arrays of storage buffers can be accessed with constant indices 1748 platform.VkBool32 shaderStorageImageArrayConstantIndexing /// arrays of storage images can be accessed with constant indices 1749 platform.VkBool32 shaderUniformBufferArrayDynamicIndexing /// arrays of uniform buffers can be accessed with dynamically uniform indices 1750 platform.VkBool32 shaderSampledImageArrayDynamicIndexing /// arrays of sampled images can be accessed with dynamically uniform indices 1751 platform.VkBool32 shaderStorageBufferArrayDynamicIndexing /// arrays of storage buffers can be accessed with dynamically uniform indices 1752 platform.VkBool32 shaderStorageImageArrayDynamicIndexing /// arrays of storage images can be accessed with dynamically uniform indices 1753 platform.VkBool32 shaderClipDistance /// clip distance in shaders 1754 platform.VkBool32 shaderCullDistance /// cull distance in shaders 1755 platform.VkBool32 shaderFloat64 /// 64-bit floats (doubles) in shaders 1756 platform.VkBool32 shaderInt64 /// 64-bit integers in shaders 1757 platform.VkBool32 shaderFloat16 /// 16-bit floats in shaders 1758 platform.VkBool32 shaderInt16 /// 16-bit integers in shaders 1759 platform.VkBool32 shaderResourceResidency /// shader can use texture operations that return resource residency information (requires sparseNonResident support) 1760 platform.VkBool32 shaderResourceMinLOD /// shader can use texture operations that specify minimum resource LOD 1761 platform.VkBool32 sparse /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level 1762 platform.VkBool32 sparseResidencyBuffer /// Sparse resources support: GPU can access partially resident buffers 1763 platform.VkBool32 sparseResidencyImage2D /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images 1764 platform.VkBool32 sparseResidencyImage3D /// Sparse resources support: GPU can access partially resident 3D images 1765 platform.VkBool32 sparseResidency2Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples 1766 platform.VkBool32 sparseResidency4Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples 1767 platform.VkBool32 sparseResidency8Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples 1768 platform.VkBool32 sparseResidency16Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples 1769 platform.VkBool32 sparseResidencyStandard2DBlockShape /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format) 1770 platform.VkBool32 sparseResidencyStandard2DMSBlockShape /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format) 1771 platform.VkBool32 sparseResidencyStandard3DBlockShape /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format) 1772 platform.VkBool32 sparseResidencyAlignedMipSize /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail 1773 platform.VkBool32 sparseResidencyNonResident /// Sparse resources support: GPU can safely access non-resident regions of a resource, read values from read-write resources are undefined 1774 platform.VkBool32 sparseResidencyNonResidentStrict /// Sparse resources support: GPU can safely access non-resident regions of a resource, all reads return as if data is 0, writes are discarded 1775 platform.VkBool32 sparseResidencyAliased /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) 1776} 1777 1778class VkPhysicalDeviceLimits { 1779 /// resource maximum sizes 1780 u32 maxImageDimension1D /// max 1D image dimension 1781 u32 maxImageDimension2D /// max 2D image dimension 1782 u32 maxImageDimension3D /// max 3D image dimension 1783 u32 maxImageDimensionCube /// max cubemap image dimension 1784 u32 maxImageArrayLayers /// max layers for image arrays 1785 u32 maxTexelBufferSize /// max texel buffer size (bytes) 1786 u32 maxUniformBufferSize /// max uniform buffer size (bytes) 1787 u32 maxStorageBufferSize /// max storage buffer size (bytes) 1788 u32 maxPushConstantsSize /// max size of the push constants pool (bytes) 1789 /// memory limits 1790 u32 maxMemoryAllocationCount /// max number of device memory allocations supported 1791 platform.VkDeviceSize bufferImageGranularity /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage 1792 /// descriptor set limits 1793 u32 maxBoundDescriptorSets /// max number of descriptors sets that can be bound to a pipeline 1794 u32 maxDescriptorSets /// max number of allocated descriptor sets 1795 u32 maxPerStageDescriptorSamplers /// max num of samplers allowed per-stage in a descriptor set 1796 u32 maxPerStageDescriptorUniformBuffers /// max num of uniform buffers allowed per-stage in a descriptor set 1797 u32 maxPerStageDescriptorStorageBuffers /// max num of storage buffers allowed per-stage in a descriptor set 1798 u32 maxPerStageDescriptorSampledImages /// max num of sampled images allowed per-stage in a descriptor set 1799 u32 maxPerStageDescriptorStorageImages /// max num of storage images allowed per-stage in a descriptor set 1800 u32 maxDescriptorSetSamplers /// max num of samplers allowed in all stages in a descriptor set 1801 u32 maxDescriptorSetUniformBuffers /// max num of uniform buffers allowed in all stages in a descriptor set 1802 u32 maxDescriptorSetStorageBuffers /// max num of storage buffers allowed in all stages in a descriptor set 1803 u32 maxDescriptorSetSampledImages /// max num of sampled images allowed in all stages in a descriptor set 1804 u32 maxDescriptorSetStorageImages /// max num of storage images allowed in all stages in a descriptor set 1805 /// vertex stage limits 1806 u32 maxVertexInputAttributes /// max num of vertex input attribute slots 1807 u32 maxVertexInputAttributeOffset /// max vertex input attribute offset added to vertex buffer offset 1808 u32 maxVertexInputBindingStride /// max vertex input binding stride 1809 u32 maxVertexOutputComponents /// max num of output components written by vertex shader 1810 /// tessellation control stage limits 1811 u32 maxTessGenLevel /// max level supported by tess primitive generator 1812 u32 maxTessPatchSize /// max patch size (vertices) 1813 u32 maxTessControlPerVertexInputComponents /// max num of input components per-vertex in TCS 1814 u32 maxTessControlPerVertexOutputComponents /// max num of output components per-vertex in TCS 1815 u32 maxTessControlPerPatchOutputComponents /// max num of output components per-patch in TCS 1816 u32 maxTessControlTotalOutputComponents /// max total num of per-vertex and per-patch output components in TCS 1817 u32 maxTessEvaluationInputComponents /// max num of input components per vertex in TES 1818 u32 maxTessEvaluationOutputComponents /// max num of output components per vertex in TES 1819 /// geometry stage limits 1820 u32 maxGeometryShaderInvocations /// max invocation count supported in geometry shader 1821 u32 maxGeometryInputComponents /// max num of input components read in geometry stage 1822 u32 maxGeometryOutputComponents /// max num of output components written in geometry stage 1823 u32 maxGeometryOutputVertices /// max num of vertices that can be emitted in geometry stage 1824 u32 maxGeometryTotalOutputComponents /// max total num of components (all vertices) written in geometry stage 1825 /// fragment stage limits 1826 u32 maxFragmentInputComponents /// max num of input compontents read in fragment stage 1827 u32 maxFragmentOutputBuffers /// max num of output buffers written in fragment stage 1828 u32 maxFragmentDualSourceBuffers /// max num of output buffers written when using dual source blending 1829 u32 maxFragmentCombinedOutputResources /// max total num of storage buffers, storage images and output buffers 1830 /// compute stage limits 1831 u32 maxComputeSharedMemorySize /// max total storage size of work group local storage (bytes) 1832 u32[3] maxComputeWorkGroupCount /// max num of compute work groups that may be dispatched by a single command (x,y,z) 1833 u32 maxComputeWorkGroupInvocations /// max total compute invocations in a single local work group 1834 u32[3] maxComputeWorkGroupSize /// max local size of a compute work group (x,y,z) 1835 1836 u32 subPixelPrecisionBits /// num bits of subpixel precision in screen x and y 1837 u32 subTexelPrecisionBits /// num bits of subtexel precision 1838 u32 mipmapPrecisionBits /// num bits of mipmap precision 1839 1840 u32 maxDrawIndexedIndexValue /// max index value for indexed draw calls (for 32-bit indices) 1841 u32 maxDrawIndirectInstanceCount /// max instance count for indirect draw calls 1842 platform.VkBool32 primitiveRestartForPatches /// is primitive restart supported for PATCHES 1843 1844 f32 maxSamplerLodBias /// max absolute sampler level of detail bias 1845 f32 maxSamplerAnisotropy /// max degree of sampler anisotropy 1846 1847 u32 maxViewports /// max number of active viewports 1848 u32 maxDynamicViewportStates /// max number of dynamic viewport state objects 1849 u32[2] maxViewportDimensions /// max viewport dimensions (x,y) 1850 f32[2] viewportBoundsRange /// viewport bounds range (min,max) 1851 u32 viewportSubPixelBits /// num bits of subpixel precision for viewport 1852 1853 u32 minMemoryMapAlignment /// min required alignment of pointers returned by MapMemory (bytes) 1854 u32 minTexelBufferOffsetAlignment /// min required alignment for texel buffer offsets (bytes) 1855 u32 minUniformBufferOffsetAlignment /// min required alignment for uniform buffer sizes and offsets (bytes) 1856 u32 minStorageBufferOffsetAlignment /// min required alignment for storage buffer offsets (bytes) 1857 1858 u32 minTexelOffset /// min texel offset for OpTextureSampleOffset 1859 u32 maxTexelOffset /// max texel offset for OpTextureSampleOffset 1860 u32 minTexelGatherOffset /// min texel offset for OpTextureGatherOffset 1861 u32 maxTexelGatherOffset /// max texel offset for OpTextureGatherOffset 1862 f32 minInterpolationOffset /// furthest negative offset for interpolateAtOffset 1863 f32 maxInterpolationOffset /// furthest positive offset for interpolateAtOffset 1864 u32 subPixelInterpolationOffsetBits /// num of subpixel bits for interpolateAtOffset 1865 1866 u32 maxFramebufferWidth /// max width for a framebuffer 1867 u32 maxFramebufferHeight /// max height for a framebuffer 1868 u32 maxFramebufferLayers /// max layer count for a layered framebuffer 1869 u32 maxFramebufferColorSamples /// max color sample count for a framebuffer 1870 u32 maxFramebufferDepthSamples /// max depth sample count for a framebuffer 1871 u32 maxFramebufferStencilSamples /// max stencil sample count for a framebuffer 1872 u32 maxColorAttachments /// max num of framebuffer color attachments 1873 1874 u32 maxSampledImageColorSamples /// max num of color samples for a non-integer sampled image 1875 u32 maxSampledImageDepthSamples /// max num of depth/stencil samples for a sampled image 1876 u32 maxSampledImageIntegerSamples /// max num of samples supported for an integer image 1877 u32 maxStorageImageSamples /// max num of samples for a storage image 1878 u32 maxSampleMaskWords /// max num of sample mask words 1879 1880 u64 timestampFrequency /// 1/clock_tick_granularity for timestamp queries 1881 1882 u32 maxClipDistances /// max number of clip distances 1883 u32 maxCullDistances /// max number of cull distances 1884 u32 maxCombinedClipAndCullDistances /// max combined number of user clipping 1885 1886 f32[2] pointSizeRange /// range (min,max) of supported point sizes 1887 f32[2] lineWidthRange /// range (min,max) of supported line widths 1888 f32 pointSizeGranularity /// granularity of supported point sizes 1889 f32 lineWidthGranularity /// granularity of supported line widths 1890} 1891 1892class VkSemaphoreCreateInfo { 1893 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO 1894 const void* pNext /// Pointer to next structure 1895 VkSemaphoreCreateFlags flags /// Semaphore creation flags 1896} 1897 1898class VkQueryPoolCreateInfo { 1899 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO 1900 const void* pNext /// Pointer to next structure 1901 VkQueryType queryType 1902 u32 slots 1903 VkQueryPipelineStatisticFlags pipelineStatistics /// Optional 1904} 1905 1906class VkFramebufferCreateInfo { 1907 VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO 1908 const void* pNext /// Pointer to next structure 1909 VkRenderPass renderPass 1910 u32 attachmentCount 1911 const VkAttachmentBindInfo* pAttachments 1912 u32 width 1913 u32 height 1914 u32 layers 1915} 1916 1917class VkDrawIndirectCmd { 1918 u32 vertexCount 1919 u32 instanceCount 1920 u32 firstVertex 1921 u32 firstInstance 1922} 1923 1924class VkDrawIndexedIndirectCmd { 1925 u32 indexCount 1926 u32 instanceCount 1927 u32 firstIndex 1928 s32 vertexOffset 1929 u32 firstInstance 1930} 1931 1932class VkDispatchIndirectCmd { 1933 u32 x 1934 u32 y 1935 u32 z 1936} 1937 1938 1939//////////////// 1940// Commands // 1941//////////////// 1942 1943// Function pointers. TODO: add support for function pointers. 1944 1945@external type void* PFN_vkVoidFunction 1946@pfn cmd void vkVoidFunction() { 1947} 1948 1949@external type void* PFN_vkAllocFunction 1950@pfn cmd void* vkAllocFunction( 1951 void* pUserData, 1952 platform.size_t size, 1953 platform.size_t alignment, 1954 VkSystemAllocType allocType) { 1955 return ? 1956} 1957 1958@external type void* PFN_vkFreeFunction 1959@pfn cmd void vkFreeFunction( 1960 void* pUserData, 1961 void* pMem) { 1962} 1963 1964 1965// Global functions 1966 1967@threadSafety("system") 1968cmd VkResult vkCreateInstance( 1969 const VkInstanceCreateInfo* pCreateInfo, 1970 VkInstance* pInstance) { 1971 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) 1972 1973 instance := ? 1974 pInstance[0] = instance 1975 State.Instances[instance] = new!InstanceObject() 1976 1977 layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.layerCount] 1978 extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.extensionCount] 1979 1980 return ? 1981} 1982 1983@threadSafety("system") 1984cmd VkResult vkDestroyInstance( 1985 VkInstance instance) { 1986 instanceObject := GetInstance(instance) 1987 1988 State.Instances[instance] = null 1989 1990 return ? 1991} 1992 1993@threadSafety("system") 1994cmd VkResult vkEnumeratePhysicalDevices( 1995 VkInstance instance, 1996 u32* pPhysicalDeviceCount, 1997 VkPhysicalDevice* pPhysicalDevices) { 1998 instanceObject := GetInstance(instance) 1999 2000 physicalDeviceCount := as!u32(?) 2001 pPhysicalDeviceCount[0] = physicalDeviceCount 2002 physicalDevices := pPhysicalDevices[0:physicalDeviceCount] 2003 2004 for i in (0 .. physicalDeviceCount) { 2005 physicalDevice := ? 2006 physicalDevices[i] = physicalDevice 2007 if !(physicalDevice in State.PhysicalDevices) { 2008 State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance) 2009 } 2010 } 2011 2012 return ? 2013} 2014 2015cmd PFN_vkVoidFunction vkGetDeviceProcAddr( 2016 VkDevice device, 2017 const char* pName) { 2018 if device != VK_NULL_HANDLE { 2019 device := GetDevice(device) 2020 } 2021 2022 return ? 2023} 2024 2025cmd PFN_vkVoidFunction vkGetInstanceProcAddr( 2026 VkInstance instance, 2027 const char* pName) { 2028 if instance != VK_NULL_HANDLE { 2029 instanceObject := GetInstance(instance) 2030 } 2031 2032 return ? 2033} 2034 2035cmd VkResult vkGetPhysicalDeviceProperties( 2036 VkPhysicalDevice physicalDevice, 2037 VkPhysicalDeviceProperties* pProperties) { 2038 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2039 2040 properties := ? 2041 pProperties[0] = properties 2042 2043 return ? 2044} 2045 2046cmd VkResult vkGetPhysicalDeviceQueueCount( 2047 VkPhysicalDevice physicalDevice, 2048 u32* pCount) { 2049 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2050 2051 count := ? 2052 pCount[0] = count 2053 2054 return ? 2055} 2056 2057cmd VkResult vkGetPhysicalDeviceQueueProperties( 2058 VkPhysicalDevice physicalDevice, 2059 u32 count, 2060 VkPhysicalDeviceQueueProperties* pQueueProperties) { 2061 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2062 queuesProperties := pQueueProperties[0:count] 2063 for i in (0 .. count) { 2064 queueProperties := as!VkPhysicalDeviceQueueProperties(?) 2065 queuesProperties[i] = queueProperties 2066 } 2067 return ? 2068} 2069 2070cmd VkResult vkGetPhysicalDeviceMemoryProperties( 2071 VkPhysicalDevice physicalDevice, 2072 VkPhysicalDeviceMemoryProperties* pMemoryProperties) { 2073 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2074 2075 memoryProperties := ? 2076 pMemoryProperties[0] = memoryProperties 2077 2078 return ? 2079} 2080 2081cmd VkResult vkGetPhysicalDeviceFeatures( 2082 VkPhysicalDevice physicalDevice, 2083 VkPhysicalDeviceFeatures* pFeatures) { 2084 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2085 2086 features := ? 2087 pFeatures[0] = features 2088 2089 return ? 2090} 2091 2092cmd VkResult vkGetPhysicalDeviceFormatProperties( 2093 VkPhysicalDevice physicalDevice, 2094 VkFormat format, 2095 VkFormatProperties* pFormatProperties) { 2096 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2097 2098 formatProperties := ? 2099 pFormatProperties[0] = formatProperties 2100 2101 return ? 2102} 2103 2104cmd VkResult vkGetPhysicalDeviceImageFormatProperties( 2105 VkPhysicalDevice physicalDevice, 2106 VkFormat format, 2107 VkImageType type, 2108 VkImageTiling tiling, 2109 VkImageUsageFlags usage, 2110 VkImageFormatProperties* pImageFormatProperties) { 2111 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2112 2113 imageFormatProperties := ? 2114 pImageFormatProperties[0] = imageFormatProperties 2115 2116 return ? 2117} 2118 2119cmd VkResult vkGetPhysicalDeviceLimits( 2120 VkPhysicalDevice physicalDevice, 2121 VkPhysicalDeviceLimits* pLimits) { 2122 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2123 2124 limits := ? 2125 pLimits[0] = limits 2126 2127 return ? 2128} 2129 2130 2131// Device functions 2132 2133@threadSafety("system") 2134cmd VkResult vkCreateDevice( 2135 VkPhysicalDevice physicalDevice, 2136 const VkDeviceCreateInfo* pCreateInfo, 2137 VkDevice* pDevice) { 2138 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO) 2139 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2140 2141 device := ? 2142 pDevice[0] = device 2143 State.Devices[device] = new!DeviceObject(physicalDevice: physicalDevice) 2144 2145 return ? 2146} 2147 2148@threadSafety("system") 2149cmd VkResult vkDestroyDevice( 2150 VkDevice device) { 2151 deviceObject := GetDevice(device) 2152 2153 State.Devices[device] = null 2154 2155 return ? 2156} 2157 2158 2159// Extension discovery functions 2160 2161cmd VkResult vkGetGlobalLayerProperties( 2162 u32* pCount, 2163 VkLayerProperties* pProperties) { 2164 count := as!u32(?) 2165 pCount[0] = count 2166 2167 properties := pProperties[0:count] 2168 for i in (0 .. count) { 2169 property := ? 2170 properties[i] = property 2171 } 2172 2173 return ? 2174} 2175 2176cmd VkResult vkGetGlobalExtensionProperties( 2177 const char* pLayerName, 2178 u32* pCount, 2179 VkExtensionProperties* pProperties) { 2180 count := as!u32(?) 2181 pCount[0] = count 2182 2183 properties := pProperties[0:count] 2184 for i in (0 .. count) { 2185 property := ? 2186 properties[i] = property 2187 } 2188 2189 return ? 2190} 2191 2192cmd VkResult vkGetPhysicalDeviceLayerProperties( 2193 VkPhysicalDevice physicalDevice, 2194 u32* pCount, 2195 VkLayerProperties* pProperties) { 2196 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2197 count := as!u32(?) 2198 pCount[0] = count 2199 2200 properties := pProperties[0:count] 2201 for i in (0 .. count) { 2202 property := ? 2203 properties[i] = property 2204 } 2205 2206 return ? 2207} 2208 2209cmd VkResult vkGetPhysicalDeviceExtensionProperties( 2210 VkPhysicalDevice physicalDevice, 2211 const char* pLayerName, 2212 u32* pCount, 2213 VkExtensionProperties* pProperties) { 2214 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2215 2216 count := as!u32(?) 2217 pCount[0] = count 2218 2219 properties := pProperties[0:count] 2220 for i in (0 .. count) { 2221 property := ? 2222 properties[i] = property 2223 } 2224 2225 return ? 2226} 2227 2228 2229// Queue functions 2230 2231@threadSafety("system") 2232cmd VkResult vkGetDeviceQueue( 2233 VkDevice device, 2234 u32 queueFamilyIndex, 2235 u32 queueIndex, 2236 VkQueue* pQueue) { 2237 deviceObject := GetDevice(device) 2238 2239 queue := ? 2240 pQueue[0] = queue 2241 2242 if !(queue in State.Queues) { 2243 State.Queues[queue] = new!QueueObject(device: device) 2244 } 2245 2246 return ? 2247} 2248 2249@threadSafety("app") 2250cmd VkResult vkQueueSubmit( 2251 VkQueue queue, 2252 u32 cmdBufferCount, 2253 const VkCmdBuffer* pCmdBuffers, 2254 VkFence fence) { 2255 queueObject := GetQueue(queue) 2256 2257 if fence != VK_NULL_HANDLE { 2258 fenceObject := GetFence(fence) 2259 assert(fenceObject.device == queueObject.device) 2260 } 2261 2262 cmdBuffers := pCmdBuffers[0:cmdBufferCount] 2263 for i in (0 .. cmdBufferCount) { 2264 cmdBuffer := cmdBuffers[i] 2265 cmdBufferObject := GetCmdBuffer(cmdBuffer) 2266 assert(cmdBufferObject.device == queueObject.device) 2267 2268 validate("QueueCheck", cmdBufferObject.queueFlags in queueObject.flags, 2269 "vkQueueSubmit: enqueued cmdBuffer requires missing queue capabilities.") 2270 } 2271 2272 return ? 2273} 2274 2275@threadSafety("system") 2276cmd VkResult vkQueueWaitIdle( 2277 VkQueue queue) { 2278 queueObject := GetQueue(queue) 2279 2280 return ? 2281} 2282 2283@threadSafety("system") 2284cmd VkResult vkDeviceWaitIdle( 2285 VkDevice device) { 2286 deviceObject := GetDevice(device) 2287 2288 return ? 2289} 2290 2291 2292// Memory functions 2293 2294@threadSafety("system") 2295cmd VkResult vkAllocMemory( 2296 VkDevice device, 2297 const VkMemoryAllocInfo* pAllocInfo, 2298 VkDeviceMemory* pMem) { 2299 assert(pAllocInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO) 2300 deviceObject := GetDevice(device) 2301 2302 mem := ? 2303 pMem[0] = mem 2304 State.DeviceMemories[mem] = new!DeviceMemoryObject( 2305 device: device, 2306 allocationSize: pAllocInfo[0].allocationSize) 2307 2308 return ? 2309} 2310 2311@threadSafety("system") 2312cmd VkResult vkFreeMemory( 2313 VkDevice device, 2314 VkDeviceMemory mem) { 2315 deviceObject := GetDevice(device) 2316 memObject := GetDeviceMemory(mem) 2317 assert(memObject.device == device) 2318 2319 // Check that no objects are still bound before freeing. 2320 validate("MemoryCheck", len(memObject.boundObjects) == 0, 2321 "vkFreeMemory: objects still bound") 2322 validate("MemoryCheck", len(memObject.boundCommandBuffers) == 0, 2323 "vkFreeMemory: cmdBuffers still bound") 2324 State.DeviceMemories[mem] = null 2325 2326 return ? 2327} 2328 2329@threadSafety("app") 2330cmd VkResult vkMapMemory( 2331 VkDevice device, 2332 VkDeviceMemory mem, 2333 platform.VkDeviceSize offset, 2334 platform.VkDeviceSize size, 2335 VkMemoryMapFlags flags, 2336 void** ppData) { 2337 deviceObject := GetDevice(device) 2338 memObject := GetDeviceMemory(mem) 2339 assert(memObject.device == device) 2340 2341 assert(flags == as!VkMemoryMapFlags(0)) 2342 assert((offset + size) <= memObject.allocationSize) 2343 2344 return ? 2345} 2346 2347@threadSafety("app") 2348cmd VkResult vkUnmapMemory( 2349 VkDevice device, 2350 VkDeviceMemory mem) { 2351 deviceObject := GetDevice(device) 2352 memObject := GetDeviceMemory(mem) 2353 assert(memObject.device == device) 2354 2355 return ? 2356} 2357 2358cmd VkResult vkFlushMappedMemoryRanges( 2359 VkDevice device, 2360 u32 memRangeCount 2361 const VkMappedMemoryRange* pMemRanges) { 2362 deviceObject := GetDevice(device) 2363 2364 memRanges := pMemRanges[0:memRangeCount] 2365 for i in (0 .. memRangeCount) { 2366 memRange := memRanges[i] 2367 memObject := GetDeviceMemory(memRange.mem) 2368 assert(memObject.device == device) 2369 assert((memRange.offset + memRange.size) <= memObject.allocationSize) 2370 } 2371 2372 return ? 2373} 2374 2375cmd VkResult vkInvalidateMappedMemoryRanges( 2376 VkDevice device, 2377 u32 memRangeCount, 2378 const VkMappedMemoryRange* pMemRanges) { 2379 deviceObject := GetDevice(device) 2380 2381 memRanges := pMemRanges[0:memRangeCount] 2382 for i in (0 .. memRangeCount) { 2383 memRange := memRanges[i] 2384 memObject := GetDeviceMemory(memRange.mem) 2385 assert(memObject.device == device) 2386 assert((memRange.offset + memRange.size) <= memObject.allocationSize) 2387 } 2388 2389 return ? 2390} 2391 2392 2393// Memory management API functions 2394 2395cmd VkResult vkGetDeviceMemoryCommitment( 2396 VkDevice device, 2397 VkDeviceMemory memory, 2398 platform.VkDeviceSize* pCommittedMemoryInBytes) { 2399 deviceObject := GetDevice(device) 2400 2401 if memory != VK_NULL_HANDLE { 2402 memoryObject := GetDeviceMemory(memory) 2403 assert(memoryObject.device == device) 2404 } 2405 2406 committedMemoryInBytes := ? 2407 pCommittedMemoryInBytes[0] = committedMemoryInBytes 2408 2409 return ? 2410} 2411 2412cmd VkResult vkGetBufferMemoryRequirements( 2413 VkDevice device, 2414 VkBuffer buffer, 2415 VkMemoryRequirements* pMemoryRequirements) { 2416 deviceObject := GetDevice(device) 2417 bufferObject := GetBuffer(buffer) 2418 assert(bufferObject.device == device) 2419 2420 return ? 2421} 2422 2423cmd VkResult vkBindBufferMemory( 2424 VkDevice device, 2425 VkBuffer buffer, 2426 VkDeviceMemory mem, 2427 platform.VkDeviceSize memOffset) { 2428 deviceObject := GetDevice(device) 2429 bufferObject := GetBuffer(buffer) 2430 assert(bufferObject.device == device) 2431 2432 // Unbind buffer from previous memory object, if not VK_NULL_HANDLE. 2433 if bufferObject.mem != VK_NULL_HANDLE { 2434 memObject := GetDeviceMemory(bufferObject.mem) 2435 memObject.boundObjects[as!u64(buffer)] = null 2436 } 2437 2438 // Bind buffer to given memory object, if not VK_NULL_HANDLE. 2439 if mem != VK_NULL_HANDLE { 2440 memObject := GetDeviceMemory(mem) 2441 assert(memObject.device == device) 2442 memObject.boundObjects[as!u64(buffer)] = memOffset 2443 } 2444 bufferObject.mem = mem 2445 bufferObject.memOffset = memOffset 2446 2447 return ? 2448} 2449 2450cmd VkResult vkGetImageMemoryRequirements( 2451 VkDevice device, 2452 VkImage image, 2453 VkMemoryRequirements* pMemoryRequirements) { 2454 deviceObject := GetDevice(device) 2455 imageObject := GetImage(image) 2456 assert(imageObject.device == device) 2457 2458 return ? 2459} 2460 2461cmd VkResult vkBindImageMemory( 2462 VkDevice device, 2463 VkImage image, 2464 VkDeviceMemory mem, 2465 platform.VkDeviceSize memOffset) { 2466 deviceObject := GetDevice(device) 2467 imageObject := GetImage(image) 2468 assert(imageObject.device == device) 2469 2470 // Unbind image from previous memory object, if not VK_NULL_HANDLE. 2471 if imageObject.mem != VK_NULL_HANDLE { 2472 memObject := GetDeviceMemory(imageObject.mem) 2473 memObject.boundObjects[as!u64(image)] = null 2474 } 2475 2476 // Bind image to given memory object, if not VK_NULL_HANDLE. 2477 if mem != VK_NULL_HANDLE { 2478 memObject := GetDeviceMemory(mem) 2479 assert(memObject.device == device) 2480 memObject.boundObjects[as!u64(image)] = memOffset 2481 } 2482 imageObject.mem = mem 2483 imageObject.memOffset = memOffset 2484 2485 return ? 2486} 2487 2488cmd VkResult vkGetImageSparseMemoryRequirements( 2489 VkDevice device, 2490 VkImage image, 2491 u32* pNumRequirements, 2492 VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { 2493 deviceObject := GetDevice(device) 2494 imageObject := GetImage(image) 2495 assert(imageObject.device == device) 2496 2497 return ? 2498} 2499 2500cmd VkResult vkGetPhysicalDeviceSparseImageFormatProperties( 2501 VkPhysicalDevice physicalDevice, 2502 VkFormat format, 2503 VkImageType type, 2504 u32 samples, 2505 VkImageUsageFlags usage, 2506 VkImageTiling tiling, 2507 u32* pNumProperties, 2508 VkSparseImageFormatProperties* pProperties) { 2509 physicalDeviceObject := GetPhysicalDevice(physicalDevice) 2510 2511 return ? 2512} 2513 2514cmd VkResult vkQueueBindSparseBufferMemory( 2515 VkQueue queue, 2516 VkBuffer buffer, 2517 u32 numBindings, 2518 const VkSparseMemoryBindInfo* pBindInfo) { 2519 queueObject := GetQueue(queue) 2520 bufferObject := GetBuffer(buffer) 2521 assert(bufferObject.device == queueObject.device) 2522 2523 return ? 2524} 2525 2526cmd VkResult vkQueueBindSparseImageOpaqueMemory( 2527 VkQueue queue, 2528 VkImage image, 2529 u32 numBindings, 2530 const VkSparseMemoryBindInfo* pBindInfo) { 2531 queueObject := GetQueue(queue) 2532 imageObject := GetImage(image) 2533 assert(imageObject.device == queueObject.device) 2534 2535 return ? 2536} 2537 2538 2539cmd VkResult vkQueueBindSparseImageMemory( 2540 VkQueue queue, 2541 VkImage image, 2542 u32 numBindings, 2543 const VkSparseImageMemoryBindInfo* pBindInfo) { 2544 queueObject := GetQueue(queue) 2545 imageObject := GetImage(image) 2546 2547 return ? 2548} 2549 2550 2551// Fence functions 2552 2553@threadSafety("system") 2554cmd VkResult vkCreateFence( 2555 VkDevice device, 2556 const VkFenceCreateInfo* pCreateInfo, 2557 VkFence* pFence) { 2558 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO) 2559 deviceObject := GetDevice(device) 2560 2561 fence := ? 2562 pFence[0] = fence 2563 State.Fences[fence] = new!FenceObject( 2564 device: device, signaled: (pCreateInfo.flags == VK_FENCE_CREATE_SIGNALED_BIT)) 2565 2566 return ? 2567} 2568 2569@threadSafety("system") 2570cmd VkResult vkDestroyFence( 2571 VkDevice device, 2572 VkFence fence) { 2573 deviceObject := GetDevice(device) 2574 fenceObject := GetFence(fence) 2575 assert(fenceObject.device == device) 2576 2577 State.Fences[fence] = null 2578 2579 return ? 2580} 2581 2582@threadSafety("system") 2583cmd VkResult vkResetFences( 2584 VkDevice device, 2585 u32 fenceCount, 2586 const VkFence* pFences) { 2587 deviceObject := GetDevice(device) 2588 2589 fences := pFences[0:fenceCount] 2590 for i in (0 .. fenceCount) { 2591 fence := fences[i] 2592 fenceObject := GetFence(fence) 2593 assert(fenceObject.device == device) 2594 fenceObject.signaled = false 2595 } 2596 2597 return ? 2598} 2599 2600@threadSafety("system") 2601cmd VkResult vkGetFenceStatus( 2602 VkDevice device, 2603 VkFence fence) { 2604 deviceObject := GetDevice(device) 2605 fenceObject := GetFence(fence) 2606 assert(fenceObject.device == device) 2607 2608 return ? 2609} 2610 2611@threadSafety("system") 2612cmd VkResult vkWaitForFences( 2613 VkDevice device, 2614 u32 fenceCount, 2615 const VkFence* pFences, 2616 platform.VkBool32 waitAll, 2617 u64 timeout) { /// timeout in nanoseconds 2618 deviceObject := GetDevice(device) 2619 2620 fences := pFences[0:fenceCount] 2621 for i in (0 .. fenceCount) { 2622 fence := fences[i] 2623 fenceObject := GetFence(fence) 2624 assert(fenceObject.device == device) 2625 } 2626 2627 return ? 2628} 2629 2630 2631// Queue semaphore functions 2632 2633@threadSafety("system") 2634cmd VkResult vkCreateSemaphore( 2635 VkDevice device, 2636 const VkSemaphoreCreateInfo* pCreateInfo, 2637 VkSemaphore* pSemaphore) { 2638 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) 2639 deviceObject := GetDevice(device) 2640 2641 semaphore := ? 2642 pSemaphore[0] = semaphore 2643 State.Semaphores[semaphore] = new!SemaphoreObject(device: device) 2644 2645 return ? 2646} 2647 2648@threadSafety("system") 2649cmd VkResult vkDestroySemaphore( 2650 VkDevice device, 2651 VkSemaphore semaphore) { 2652 deviceObject := GetDevice(device) 2653 semaphoreObject := GetSemaphore(semaphore) 2654 assert(semaphoreObject.device == device) 2655 2656 State.Semaphores[semaphore] = null 2657 2658 return ? 2659} 2660 2661@threadSafety("app") 2662cmd VkResult vkQueueSignalSemaphore( 2663 VkQueue queue, 2664 VkSemaphore semaphore) { 2665 queueObject := GetQueue(queue) 2666 semaphoreObject := GetSemaphore(semaphore) 2667 assert(queueObject.device == semaphoreObject.device) 2668 2669 return ? 2670} 2671 2672@threadSafety("system") 2673cmd VkResult vkQueueWaitSemaphore( 2674 VkQueue queue, 2675 VkSemaphore semaphore) { 2676 queueObject := GetQueue(queue) 2677 semaphoreObject := GetSemaphore(semaphore) 2678 assert(queueObject.device == semaphoreObject.device) 2679 2680 return ? 2681} 2682 2683 2684// Event functions 2685 2686@threadSafety("system") 2687cmd VkResult vkCreateEvent( 2688 VkDevice device, 2689 const VkEventCreateInfo* pCreateInfo, 2690 VkEvent* pEvent) { 2691 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO) 2692 deviceObject := GetDevice(device) 2693 2694 event := ? 2695 pEvent[0] = event 2696 State.Events[event] = new!EventObject(device: device) 2697 2698 return ? 2699} 2700 2701@threadSafety("system") 2702cmd VkResult vkDestroyEvent( 2703 VkDevice device, 2704 VkEvent event) { 2705 deviceObject := GetDevice(device) 2706 eventObject := GetEvent(event) 2707 assert(eventObject.device == device) 2708 2709 State.Events[event] = null 2710 2711 return ? 2712} 2713 2714@threadSafety("system") 2715cmd VkResult vkGetEventStatus( 2716 VkDevice device, 2717 VkEvent event) { 2718 deviceObject := GetDevice(device) 2719 eventObject := GetEvent(event) 2720 assert(eventObject.device == device) 2721 2722 return ? 2723} 2724 2725@threadSafety("system") 2726cmd VkResult vkSetEvent( 2727 VkDevice device, 2728 VkEvent event) { 2729 deviceObject := GetDevice(device) 2730 eventObject := GetEvent(event) 2731 assert(eventObject.device == device) 2732 2733 return ? 2734} 2735 2736@threadSafety("system") 2737cmd VkResult vkResetEvent( 2738 VkDevice device, 2739 VkEvent event) { 2740 deviceObject := GetDevice(device) 2741 eventObject := GetEvent(event) 2742 assert(eventObject.device == device) 2743 2744 return ? 2745} 2746 2747 2748// Query functions 2749 2750@threadSafety("system") 2751cmd VkResult vkCreateQueryPool( 2752 VkDevice device, 2753 const VkQueryPoolCreateInfo* pCreateInfo, 2754 VkQueryPool* pQueryPool) { 2755 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO) 2756 deviceObject := GetDevice(device) 2757 2758 queryPool := ? 2759 pQueryPool[0] = queryPool 2760 State.QueryPools[queryPool] = new!QueryPoolObject(device: device) 2761 2762 return ? 2763} 2764 2765@threadSafety("system") 2766cmd VkResult vkDestroyQueryPool( 2767 VkDevice device, 2768 VkQueryPool queryPool) { 2769 deviceObject := GetDevice(device) 2770 queryPoolObject := GetQueryPool(queryPool) 2771 assert(queryPoolObject.device == device) 2772 2773 State.QueryPools[queryPool] = null 2774 2775 return ? 2776} 2777 2778@threadSafety("system") 2779cmd VkResult vkGetQueryPoolResults( 2780 VkDevice device, 2781 VkQueryPool queryPool, 2782 u32 startQuery, 2783 u32 queryCount, 2784 platform.size_t* pDataSize, 2785 void* pData, 2786 VkQueryResultFlags flags) { 2787 deviceObject := GetDevice(device) 2788 queryPoolObject := GetQueryPool(queryPool) 2789 assert(queryPoolObject.device == device) 2790 2791 dataSize := ? 2792 pDataSize[0] = dataSize 2793 data := pData[0:dataSize] 2794 2795 return ? 2796} 2797 2798// Buffer functions 2799 2800@threadSafety("system") 2801cmd VkResult vkCreateBuffer( 2802 VkDevice device, 2803 const VkBufferCreateInfo* pCreateInfo, 2804 VkBuffer* pBuffer) { 2805 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) 2806 deviceObject := GetDevice(device) 2807 2808 buffer := ? 2809 pBuffer[0] = buffer 2810 State.Buffers[buffer] = new!BufferObject(device: device) 2811 2812 return ? 2813} 2814 2815@threadSafety("system") 2816cmd VkResult vkDestroyBuffer( 2817 VkDevice device, 2818 VkBuffer buffer) { 2819 deviceObject := GetDevice(device) 2820 bufferObject := GetBuffer(buffer) 2821 assert(bufferObject.device == device) 2822 2823 assert(bufferObject.mem == 0) 2824 State.Buffers[buffer] = null 2825 2826 return ? 2827} 2828 2829 2830// Buffer view functions 2831 2832@threadSafety("system") 2833cmd VkResult vkCreateBufferView( 2834 VkDevice device, 2835 const VkBufferViewCreateInfo* pCreateInfo, 2836 VkBufferView* pView) { 2837 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO) 2838 deviceObject := GetDevice(device) 2839 2840 bufferObject := GetBuffer(pCreateInfo.buffer) 2841 assert(bufferObject.device == device) 2842 2843 view := ? 2844 pView[0] = view 2845 State.BufferViews[view] = new!BufferViewObject(device: device, buffer: pCreateInfo.buffer) 2846 2847 return ? 2848} 2849 2850@threadSafety("system") 2851cmd VkResult vkDestroyBufferView( 2852 VkDevice device, 2853 VkBufferView bufferView) { 2854 deviceObject := GetDevice(device) 2855 bufferViewObject := GetBufferView(bufferView) 2856 assert(bufferViewObject.device == device) 2857 2858 State.BufferViews[bufferView] = null 2859 2860 return ? 2861} 2862 2863 2864// Image functions 2865 2866@threadSafety("system") 2867cmd VkResult vkCreateImage( 2868 VkDevice device, 2869 const VkImageCreateInfo* pCreateInfo, 2870 VkImage* pImage) { 2871 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) 2872 deviceObject := GetDevice(device) 2873 2874 image := ? 2875 pImage[0] = image 2876 State.Images[image] = new!ImageObject(device: device) 2877 2878 return ? 2879} 2880 2881@threadSafety("system") 2882cmd VkResult vkDestroyImage( 2883 VkDevice device, 2884 VkImage image) { 2885 deviceObject := GetDevice(device) 2886 imageObject := GetImage(image) 2887 assert(imageObject.device == device) 2888 2889 assert(imageObject.mem == 0) 2890 State.Images[image] = null 2891 2892 return ? 2893} 2894 2895cmd VkResult vkGetImageSubresourceLayout( 2896 VkDevice device, 2897 VkImage image, 2898 const VkImageSubresource* pSubresource, 2899 VkSubresourceLayout* pLayout) { 2900 deviceObject := GetDevice(device) 2901 imageObject := GetImage(image) 2902 assert(imageObject.device == device) 2903 2904 return ? 2905} 2906 2907 2908// Image view functions 2909 2910@threadSafety("system") 2911cmd VkResult vkCreateImageView( 2912 VkDevice device, 2913 const VkImageViewCreateInfo* pCreateInfo, 2914 VkImageView* pView) { 2915 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) 2916 deviceObject := GetDevice(device) 2917 2918 imageObject := GetImage(pCreateInfo.image) 2919 assert(imageObject.device == device) 2920 2921 view := ? 2922 pView[0] = view 2923 State.ImageViews[view] = new!ImageViewObject(device: device, image: pCreateInfo.image) 2924 2925 return ? 2926} 2927 2928@threadSafety("system") 2929cmd VkResult vkDestroyImageView( 2930 VkDevice device, 2931 VkImageView imageView) { 2932 deviceObject := GetDevice(device) 2933 imageViewObject := GetImageView(imageView) 2934 assert(imageViewObject.device == device) 2935 2936 State.ImageViews[imageView] = null 2937 2938 return ? 2939} 2940 2941@threadSafety("system") 2942cmd VkResult vkCreateAttachmentView( 2943 VkDevice device, 2944 const VkAttachmentViewCreateInfo* pCreateInfo, 2945 VkAttachmentView* pView) { 2946 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO) 2947 deviceObject := GetDevice(device) 2948 2949 imageObject := GetImage(pCreateInfo.image) 2950 assert(imageObject.device == device) 2951 2952 view := ? 2953 pView[0] = view 2954 State.AttachmentViews[view] = new!AttachmentViewObject(device: device, image: pCreateInfo.image) 2955 2956 return ? 2957} 2958 2959@threadSafety("system") 2960cmd VkResult vkDestroyAttachmentView( 2961 VkDevice device, 2962 VkAttachmentView attachmentView) { 2963 deviceObject := GetDevice(device) 2964 attachmentViewObject := GetAttachmentView(attachmentView) 2965 assert(attachmentViewObject.device == device) 2966 2967 State.AttachmentViews[attachmentView] = null 2968 2969 return ? 2970} 2971 2972 2973// Shader functions 2974 2975cmd VkResult vkCreateShaderModule( 2976 VkDevice device, 2977 const VkShaderModuleCreateInfo* pCreateInfo, 2978 VkShaderModule* pShaderModule) { 2979 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) 2980 deviceObject := GetDevice(device) 2981 2982 shaderModule := ? 2983 pShaderModule[0] = shaderModule 2984 State.ShaderModules[shaderModule] = new!ShaderModuleObject(device: device) 2985 2986 return ? 2987} 2988 2989cmd VkResult vkDestroyShaderModule( 2990 VkDevice device, 2991 VkShaderModule shaderModule) { 2992 deviceObject := GetDevice(device) 2993 shaderModuleObject := GetShaderModule(shaderModule) 2994 assert(shaderModuleObject.device == device) 2995 2996 State.ShaderModules[shaderModule] = null 2997 2998 return ? 2999} 3000 3001@threadSafety("system") 3002cmd VkResult vkCreateShader( 3003 VkDevice device, 3004 const VkShaderCreateInfo* pCreateInfo, 3005 VkShader* pShader) { 3006 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_CREATE_INFO) 3007 deviceObject := GetDevice(device) 3008 3009 shader := ? 3010 pShader[0] = shader 3011 State.Shaders[shader] = new!ShaderObject(device: device) 3012 3013 return ? 3014} 3015 3016@threadSafety("system") 3017cmd VkResult vkDestroyShader( 3018 VkDevice device, 3019 VkShader shader) { 3020 deviceObject := GetDevice(device) 3021 shaderObject := GetShader(shader) 3022 assert(shaderObject.device == device) 3023 3024 State.Shaders[shader] = null 3025 3026 return ? 3027} 3028 3029 3030// Pipeline functions 3031 3032cmd VkResult vkCreatePipelineCache( 3033 VkDevice device, 3034 const VkPipelineCacheCreateInfo* pCreateInfo, 3035 VkPipelineCache* pPipelineCache) { 3036 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO) 3037 deviceObject := GetDevice(device) 3038 3039 pipelineCache := ? 3040 pPipelineCache[0] = pipelineCache 3041 State.PipelineCaches[pipelineCache] = new!PipelineCacheObject(device: device) 3042 3043 return ? 3044} 3045 3046cmd VkResult vkDestroyPipelineCache( 3047 VkDevice device, 3048 VkPipelineCache pipelineCache) { 3049 deviceObject := GetDevice(device) 3050 pipelineCacheObject := GetPipelineCache(pipelineCache) 3051 assert(pipelineCacheObject.device == device) 3052 3053 State.PipelineCaches[pipelineCache] = null 3054 3055 return ? 3056} 3057 3058cmd platform.size_t vkGetPipelineCacheSize( 3059 VkDevice device, 3060 VkPipelineCache pipelineCache) { 3061 deviceObject := GetDevice(device) 3062 pipelineCacheObject := GetPipelineCache(pipelineCache) 3063 assert(pipelineCacheObject.device == device) 3064 3065 return ? 3066} 3067 3068cmd VkResult vkGetPipelineCacheData( 3069 VkDevice device, 3070 VkPipelineCache pipelineCache, 3071 void* pData) { 3072 deviceObject := GetDevice(device) 3073 pipelineCacheObject := GetPipelineCache(pipelineCache) 3074 assert(pipelineCacheObject.device == device) 3075 3076 return ? 3077} 3078 3079cmd VkResult vkMergePipelineCaches( 3080 VkDevice device, 3081 VkPipelineCache destCache, 3082 u32 srcCacheCount, 3083 const VkPipelineCache* pSrcCaches) { 3084 deviceObject := GetDevice(device) 3085 destCacheObject := GetPipelineCache(destCache) 3086 assert(destCacheObject.device == device) 3087 3088 srcCaches := pSrcCaches[0:srcCacheCount] 3089 for i in (0 .. srcCacheCount) { 3090 srcCache := srcCaches[i] 3091 srcCacheObject := GetPipelineCache(srcCache) 3092 assert(srcCacheObject.device == device) 3093 } 3094 3095 return ? 3096} 3097 3098cmd VkResult vkCreateGraphicsPipelines( 3099 VkDevice device, 3100 VkPipelineCache pipelineCache, 3101 u32 count, 3102 const VkGraphicsPipelineCreateInfo* pCreateInfos, 3103 VkPipeline* pPipelines) { 3104 deviceObject := GetDevice(device) 3105 if pipelineCache != VK_NULL_HANDLE { 3106 pipelineCacheObject := GetPipelineCache(pipelineCache) 3107 assert(pipelineCacheObject.device == device) 3108 } 3109 3110 createInfos := pCreateInfos[0:count] 3111 pipelines := pPipelines[0:count] 3112 for i in (0 .. count) { 3113 pipeline := ? 3114 pipelines[i] = pipeline 3115 State.Pipelines[pipeline] = new!PipelineObject(device: device) 3116 } 3117 3118 return ? 3119} 3120 3121cmd VkResult vkCreateComputePipelines( 3122 VkDevice device, 3123 VkPipelineCache pipelineCache, 3124 u32 count, 3125 const VkComputePipelineCreateInfo* pCreateInfos, 3126 VkPipeline* pPipelines) { 3127 deviceObject := GetDevice(device) 3128 if pipelineCache != VK_NULL_HANDLE { 3129 pipelineCacheObject := GetPipelineCache(pipelineCache) 3130 assert(pipelineCacheObject.device == device) 3131 } 3132 3133 createInfos := pCreateInfos[0:count] 3134 pipelines := pPipelines[0:count] 3135 for i in (0 .. count) { 3136 pipeline := ? 3137 pipelines[i] = pipeline 3138 State.Pipelines[pipeline] = new!PipelineObject(device: device) 3139 } 3140 3141 return ? 3142} 3143 3144@threadSafety("system") 3145cmd VkResult vkDestroyPipeline( 3146 VkDevice device, 3147 VkPipeline pipeline) { 3148 deviceObject := GetDevice(device) 3149 pipelineObjects := GetPipeline(pipeline) 3150 assert(pipelineObjects.device == device) 3151 3152 State.Pipelines[pipeline] = null 3153 3154 return ? 3155} 3156 3157 3158// Pipeline layout functions 3159 3160@threadSafety("system") 3161cmd VkResult vkCreatePipelineLayout( 3162 VkDevice device, 3163 const VkPipelineLayoutCreateInfo* pCreateInfo, 3164 VkPipelineLayout* pPipelineLayout) { 3165 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO) 3166 deviceObject := GetDevice(device) 3167 3168 pipelineLayout := ? 3169 pPipelineLayout[0] = pipelineLayout 3170 State.PipelineLayouts[pipelineLayout] = new!PipelineLayoutObject(device: device) 3171 3172 return ? 3173} 3174 3175@threadSafety("system") 3176cmd VkResult vkDestroyPipelineLayout( 3177 VkDevice device, 3178 VkPipelineLayout pipelineLayout) { 3179 deviceObject := GetDevice(device) 3180 pipelineLayoutObjects := GetPipelineLayout(pipelineLayout) 3181 assert(pipelineLayoutObjects.device == device) 3182 3183 State.PipelineLayouts[pipelineLayout] = null 3184 3185 return ? 3186} 3187 3188 3189// Sampler functions 3190 3191@threadSafety("system") 3192cmd VkResult vkCreateSampler( 3193 VkDevice device, 3194 const VkSamplerCreateInfo* pCreateInfo, 3195 VkSampler* pSampler) { 3196 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) 3197 deviceObject := GetDevice(device) 3198 3199 sampler := ? 3200 pSampler[0] = sampler 3201 State.Samplers[sampler] = new!SamplerObject(device: device) 3202 3203 return ? 3204} 3205 3206@threadSafety("system") 3207cmd VkResult vkDestroySampler( 3208 VkDevice device, 3209 VkSampler sampler) { 3210 deviceObject := GetDevice(device) 3211 samplerObject := GetSampler(sampler) 3212 assert(samplerObject.device == device) 3213 3214 State.Samplers[sampler] = null 3215 3216 return ? 3217} 3218 3219 3220// Descriptor set functions 3221 3222@threadSafety("system") 3223cmd VkResult vkCreateDescriptorSetLayout( 3224 VkDevice device, 3225 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 3226 VkDescriptorSetLayout* pSetLayout) { 3227 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) 3228 deviceObject := GetDevice(device) 3229 3230 setLayout := ? 3231 pSetLayout[0] = setLayout 3232 State.DescriptorSetLayouts[setLayout] = new!DescriptorSetLayoutObject(device: device) 3233 3234 return ? 3235} 3236 3237@threadSafety("system") 3238cmd VkResult vkDestroyDescriptorSetLayout( 3239 VkDevice device, 3240 VkDescriptorSetLayout descriptorSetLayout) { 3241 deviceObject := GetDevice(device) 3242 descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout) 3243 assert(descriptorSetLayoutObject.device == device) 3244 3245 State.DescriptorSetLayouts[descriptorSetLayout] = null 3246 3247 return ? 3248} 3249 3250@threadSafety("system") 3251cmd VkResult vkCreateDescriptorPool( 3252 VkDevice device, 3253 VkDescriptorPoolUsage poolUsage, 3254 u32 maxSets, 3255 const VkDescriptorPoolCreateInfo* pCreateInfo, 3256 VkDescriptorPool* pDescriptorPool) { 3257 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO) 3258 deviceObject := GetDevice(device) 3259 3260 descriptorPool := ? 3261 pDescriptorPool[0] = descriptorPool 3262 State.DescriptorPools[descriptorPool] = new!DescriptorPoolObject(device: device) 3263 3264 return ? 3265} 3266 3267@threadSafety("system") 3268cmd VkResult vkDestroyDescriptorPool( 3269 VkDevice device, 3270 VkDescriptorPool descriptorPool) { 3271 deviceObject := GetDevice(device) 3272 descriptorPoolObject := GetDescriptorPool(descriptorPool) 3273 assert(descriptorPoolObject.device == device) 3274 3275 State.DescriptorPools[descriptorPool] = null 3276 3277 return ? 3278} 3279 3280@threadSafety("app") 3281cmd VkResult vkResetDescriptorPool( 3282 VkDevice device, 3283 VkDescriptorPool descriptorPool) { 3284 deviceObject := GetDevice(device) 3285 descriptorPoolObject := GetDescriptorPool(descriptorPool) 3286 assert(descriptorPoolObject.device == device) 3287 3288 return ? 3289} 3290 3291@threadSafety("app") 3292cmd VkResult vkAllocDescriptorSets( 3293 VkDevice device, 3294 VkDescriptorPool descriptorPool, 3295 VkDescriptorSetUsage setUsage, 3296 u32 count, 3297 const VkDescriptorSetLayout* pSetLayouts, 3298 VkDescriptorSet* pDescriptorSets, 3299 u32* pCount) { 3300 deviceObject := GetDevice(device) 3301 descriptorPoolObject := GetDescriptorPool(descriptorPool) 3302 3303 setLayouts := pSetLayouts[0:count] 3304 for i in (0 .. count) { 3305 setLayout := setLayouts[i] 3306 setLayoutObject := GetDescriptorSetLayout(setLayout) 3307 assert(setLayoutObject.device == device) 3308 } 3309 3310 setsCount := as!u32(?) 3311 pCount[0] = setsCount 3312 descriptorSets := pDescriptorSets[0:setsCount] 3313 for i in (0 .. setsCount) { 3314 descriptorSet := ? 3315 descriptorSets[i] = descriptorSet 3316 State.DescriptorSets[descriptorSet] = new!DescriptorSetObject(device: device) 3317 } 3318 3319 return ? 3320} 3321 3322cmd VkResult vkUpdateDescriptorSets( 3323 VkDevice device, 3324 u32 writeCount, 3325 const VkWriteDescriptorSet* pDescriptorWrites, 3326 u32 copyCount, 3327 const VkCopyDescriptorSet* pDescriptorCopies) { 3328 deviceObject := GetDevice(device) 3329 3330 descriptorWrites := pDescriptorWrites[0:writeCount] 3331 for i in (0 .. writeCount) { 3332 descriptorWrite := descriptorWrites[i] 3333 descriptorWriteObject := GetDescriptorSet(descriptorWrite.destSet) 3334 assert(descriptorWriteObject.device == device) 3335 } 3336 3337 descriptorCopies := pDescriptorCopies[0:copyCount] 3338 for i in (0 .. copyCount) { 3339 descriptorCopy := descriptorCopies[i] 3340 descriptorCopyObject := GetDescriptorSet(descriptorCopy.destSet) 3341 assert(descriptorCopyObject.device == device) 3342 } 3343 3344 return ? 3345} 3346 3347 3348// State object functions 3349 3350@threadSafety("system") 3351cmd VkResult vkCreateDynamicViewportState( 3352 VkDevice device, 3353 const VkDynamicViewportStateCreateInfo* pCreateInfo, 3354 VkDynamicViewportState* pState) { 3355 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO) 3356 deviceObject := GetDevice(device) 3357 3358 state := ? 3359 pState[0] = state 3360 State.DynamicViewportStates[state] = new!DynamicViewportStateObject(device: device) 3361 3362 return ? 3363} 3364 3365@threadSafety("system") 3366cmd VkResult vkDestroyDynamicViewportState( 3367 VkDevice device, 3368 VkDynamicViewportState dynamicViewportState) { 3369 deviceObject := GetDevice(device) 3370 dynamicViewportStateObject := GetDynamicViewportState(dynamicViewportState) 3371 assert(dynamicViewportStateObject.device == device) 3372 3373 State.DynamicViewportStates[dynamicViewportState] = null 3374 3375 return ? 3376} 3377 3378@threadSafety("system") 3379cmd VkResult vkCreateDynamicRasterState( 3380 VkDevice device, 3381 const VkDynamicRasterStateCreateInfo* pCreateInfo, 3382 VkDynamicRasterState* pState) { 3383 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO) 3384 deviceObject := GetDevice(device) 3385 3386 state := ? 3387 pState[0] = state 3388 State.DynamicRasterStates[state] = new!DynamicRasterStateObject(device: device) 3389 3390 return ? 3391} 3392 3393@threadSafety("system") 3394cmd VkResult vkDestroyDynamicRasterState( 3395 VkDevice device, 3396 VkDynamicRasterState dynamicRasterState) { 3397 deviceObject := GetDevice(device) 3398 dynamicRasterStateObject := GetDynamicRasterState(dynamicRasterState) 3399 assert(dynamicRasterStateObject.device == device) 3400 3401 State.DynamicRasterStates[dynamicRasterState] = null 3402 3403 return ? 3404} 3405 3406@threadSafety("system") 3407cmd VkResult vkCreateDynamicColorBlendState( 3408 VkDevice device, 3409 const VkDynamicColorBlendStateCreateInfo* pCreateInfo, 3410 VkDynamicColorBlendState* pState) { 3411 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO) 3412 deviceObject := GetDevice(device) 3413 3414 state := ? 3415 pState[0] = state 3416 State.DynamicColorBlendStates[state] = new!DynamicColorBlendStateObject(device: device) 3417 3418 return ? 3419} 3420 3421@threadSafety("system") 3422cmd VkResult vkDestroyDynamicColorBlendState( 3423 VkDevice device, 3424 VkDynamicColorBlendState dynamicColorBlendState) { 3425 deviceObject := GetDevice(device) 3426 dynamicColorBlendStateObject := GetDynamicColorBlendState(dynamicColorBlendState) 3427 assert(dynamicColorBlendStateObject.device == device) 3428 3429 State.DynamicColorBlendStates[dynamicColorBlendState] = null 3430 3431 return ? 3432} 3433 3434@threadSafety("system") 3435cmd VkResult vkCreateDynamicDepthStencilState( 3436 VkDevice device, 3437 const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, 3438 VkDynamicDepthStencilState* pState) { 3439 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO) 3440 deviceObject := GetDevice(device) 3441 3442 state := ? 3443 pState[0] = state 3444 State.DynamicDepthStencilStates[state] = new!DynamicDepthStencilStateObject(device: device) 3445 3446 return ? 3447} 3448 3449@threadSafety("system") 3450cmd VkResult vkDestroyDynamicDepthStencilState( 3451 VkDevice device, 3452 VkDynamicDepthStencilState dynamicDepthStencilState) { 3453 deviceObject := GetDevice(device) 3454 dynamicDepthStencilStateObject := GetDynamicDepthStencilState(dynamicDepthStencilState) 3455 assert(dynamicDepthStencilStateObject.device == device) 3456 3457 State.DynamicDepthStencilStates[dynamicDepthStencilState] = null 3458 3459 return ? 3460} 3461 3462 3463// Framebuffer functions 3464 3465@threadSafety("system") 3466cmd VkResult vkCreateFramebuffer( 3467 VkDevice device, 3468 const VkFramebufferCreateInfo* pCreateInfo, 3469 VkFramebuffer* pFramebuffer) { 3470 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO) 3471 deviceObject := GetDevice(device) 3472 3473 framebuffer := ? 3474 pFramebuffer[0] = framebuffer 3475 State.Framebuffers[framebuffer] = new!FramebufferObject(device: device) 3476 3477 return ? 3478} 3479 3480@threadSafety("system") 3481cmd VkResult vkDestroyFramebuffer( 3482 VkDevice device, 3483 VkFramebuffer framebuffer) { 3484 deviceObject := GetDevice(device) 3485 framebufferObject := GetFramebuffer(framebuffer) 3486 assert(framebufferObject.device == device) 3487 3488 State.Framebuffers[framebuffer] = null 3489 3490 return ? 3491} 3492 3493 3494// Renderpass functions 3495 3496@threadSafety("system") 3497cmd VkResult vkCreateRenderPass( 3498 VkDevice device, 3499 const VkRenderPassCreateInfo* pCreateInfo, 3500 VkRenderPass* pRenderPass) { 3501 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO) 3502 deviceObject := GetDevice(device) 3503 3504 renderpass := ? 3505 pRenderPass[0] = renderpass 3506 State.RenderPasses[renderpass] = new!RenderPassObject(device: device) 3507 3508 return ? 3509} 3510 3511@threadSafety("system") 3512cmd VkResult vkDestroyRenderPass( 3513 VkDevice device, 3514 VkRenderPass renderPass) { 3515 deviceObject := GetDevice(device) 3516 renderPassObject := GetRenderPass(renderPass) 3517 assert(renderPassObject.device == device) 3518 3519 State.RenderPasses[renderPass] = null 3520 3521 return ? 3522} 3523 3524cmd VkResult vkGetRenderAreaGranularity( 3525 VkDevice device, 3526 VkRenderPass renderPass, 3527 VkExtent2D* pGranularity) { 3528 deviceObject := GetDevice(device) 3529 renderPassObject := GetRenderPass(renderPass) 3530 3531 granularity := ? 3532 pGranularity[0] = granularity 3533 3534 return ? 3535} 3536 3537// Command pool functions 3538 3539cmd VkResult vkCreateCommandPool( 3540 VkDevice device, 3541 const VkCmdPoolCreateInfo* pCreateInfo, 3542 VkCmdPool* pCmdPool) { 3543 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO) 3544 deviceObject := GetDevice(device) 3545 3546 cmdPool := ? 3547 pCmdPool[0] = cmdPool 3548 State.CmdPools[cmdPool] = new!CmdPoolObject(device: device) 3549 3550 return ? 3551} 3552 3553cmd VkResult vkDestroyCommandPool( 3554 VkDevice device, 3555 VkCmdPool cmdPool) { 3556 deviceObject := GetDevice(device) 3557 cmdPoolObject := GetCmdPool(cmdPool) 3558 assert(cmdPoolObject.device == device) 3559 3560 State.CmdPools[cmdPool] = null 3561 3562 return ? 3563} 3564 3565cmd VkResult vkResetCommandPool( 3566 VkDevice device, 3567 VkCmdPool cmdPool, 3568 VkCmdPoolResetFlags flags) { 3569 deviceObject := GetDevice(device) 3570 cmdPoolObject := GetCmdPool(cmdPool) 3571 assert(cmdPoolObject.device == device) 3572 3573 return ? 3574} 3575 3576// Command buffer functions 3577 3578macro void bindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) { 3579 memoryObject := GetDeviceMemory(mem) 3580 memoryObject.boundCommandBuffers[cmdBuffer] = cmdBuffer 3581 3582 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3583 cmdBufferObject.boundObjects[as!u64(obj)] = mem 3584} 3585 3586macro void unbindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) { 3587 memoryObject := GetDeviceMemory(mem) 3588 memoryObject.boundCommandBuffers[cmdBuffer] = null 3589 3590 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3591 cmdBufferObject.boundObjects[as!u64(obj)] = null 3592} 3593 3594@threadSafety("system") 3595cmd VkResult vkCreateCommandBuffer( 3596 VkDevice device, 3597 const VkCmdBufferCreateInfo* pCreateInfo, 3598 VkCmdBuffer* pCmdBuffer) { 3599 assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO) 3600 3601 cmdBuffer := ? 3602 pCmdBuffer[0] = cmdBuffer 3603 State.CmdBuffers[cmdBuffer] = new!CmdBufferObject(device: device) 3604 3605 return ? 3606} 3607 3608@threadSafety("system") 3609cmd VkResult vkDestroyCommandBuffer( 3610 VkDevice device, 3611 VkCmdBuffer commandBuffer) { 3612 deviceObject := GetDevice(device) 3613 cmdBufferObject := GetCmdBuffer(commandBuffer) 3614 assert(cmdBufferObject.device == device) 3615 3616 // TODO: iterate over boundObjects and clear memory bindings 3617 State.CmdBuffers[commandBuffer] = null 3618 3619 return ? 3620} 3621 3622@threadSafety("app") 3623cmd VkResult vkBeginCommandBuffer( 3624 VkCmdBuffer cmdBuffer, 3625 const VkCmdBufferBeginInfo* pBeginInfo) { 3626 assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO) 3627 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3628 3629 // TODO: iterate over boundObjects and clear memory bindings 3630 3631 return ? 3632} 3633 3634@threadSafety("app") 3635cmd VkResult vkEndCommandBuffer( 3636 VkCmdBuffer cmdBuffer) { 3637 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3638 3639 return ? 3640} 3641 3642@threadSafety("app") 3643cmd VkResult vkResetCommandBuffer( 3644 VkCmdBuffer cmdBuffer, 3645 VkCmdBufferResetFlags flags) { 3646 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3647 3648 // TODO: iterate over boundObjects and clear memory bindings 3649 3650 return ? 3651} 3652 3653 3654// Command buffer building functions 3655 3656@threadSafety("app") 3657cmd void vkCmdBindPipeline( 3658 VkCmdBuffer cmdBuffer, 3659 VkPipelineBindPoint pipelineBindPoint, 3660 VkPipeline pipeline) { 3661 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3662 pipelineObject := GetPipeline(pipeline) 3663 assert(cmdBufferObject.device == pipelineObject.device) 3664 3665 queueFlags := cmdBufferObject.queueFlags | switch (pipelineBindPoint) { 3666 case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT 3667 case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT 3668 } 3669 cmdBufferObject.queueFlags = queueFlags 3670} 3671 3672@threadSafety("app") 3673cmd void vkCmdBindDynamicViewportState( 3674 VkCmdBuffer cmdBuffer, 3675 VkDynamicViewportState dynamicViewportState) { 3676 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3677 dynamicViewportStateObject := GetDynamicViewportState(dynamicViewportState) 3678 assert(cmdBufferObject.device == dynamicViewportStateObject.device) 3679 3680 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3681 cmdBufferObject.queueFlags = queueFlags 3682} 3683 3684@threadSafety("app") 3685cmd void vkCmdBindDynamicRasterState( 3686 VkCmdBuffer cmdBuffer, 3687 VkDynamicRasterState dynamicRasterState) { 3688 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3689 dynamicRasterStateObject := GetDynamicRasterState(dynamicRasterState) 3690 assert(cmdBufferObject.device == dynamicRasterStateObject.device) 3691 3692 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3693 cmdBufferObject.queueFlags = queueFlags 3694} 3695 3696@threadSafety("app") 3697cmd void vkCmdBindDynamicColorBlendState( 3698 VkCmdBuffer cmdBuffer, 3699 VkDynamicColorBlendState dynamicColorBlendState) { 3700 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3701 dynamicColorBlendStateObject := GetDynamicColorBlendState(dynamicColorBlendState) 3702 assert(cmdBufferObject.device == dynamicColorBlendStateObject.device) 3703 3704 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3705 cmdBufferObject.queueFlags = queueFlags 3706} 3707 3708@threadSafety("app") 3709cmd void vkCmdBindDynamicDepthStencilState( 3710 VkCmdBuffer cmdBuffer, 3711 VkDynamicDepthStencilState dynamicDepthStencilState) { 3712 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3713 dynamicDepthStencilStateObject := GetDynamicDepthStencilState(dynamicDepthStencilState) 3714 assert(cmdBufferObject.device == dynamicDepthStencilStateObject.device) 3715 3716 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3717 cmdBufferObject.queueFlags = queueFlags 3718} 3719 3720@threadSafety("app") 3721cmd void vkCmdBindDescriptorSets( 3722 VkCmdBuffer cmdBuffer, 3723 VkPipelineBindPoint pipelineBindPoint, 3724 VkPipelineLayout layout, 3725 u32 firstSet, 3726 u32 setCount, 3727 const VkDescriptorSet* pDescriptorSets, 3728 u32 dynamicOffsetCount, 3729 const u32* pDynamicOffsets) { 3730 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3731 3732 descriptorSets := pDescriptorSets[0:setCount] 3733 for i in (0 .. setCount) { 3734 descriptorSet := descriptorSets[i] 3735 descriptorSetObject := GetDescriptorSet(descriptorSet) 3736 assert(cmdBufferObject.device == descriptorSetObject.device) 3737 } 3738 3739 dynamicOffsets := pDynamicOffsets[0:dynamicOffsetCount] 3740 for i in (0 .. dynamicOffsetCount) { 3741 dynamicOffset := dynamicOffsets[i] 3742 } 3743 3744 queueFlags := cmdBufferObject.queueFlags | switch (pipelineBindPoint) { 3745 case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT 3746 case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT 3747 } 3748 cmdBufferObject.queueFlags = queueFlags 3749} 3750 3751@threadSafety("app") 3752cmd void vkCmdBindIndexBuffer( 3753 VkCmdBuffer cmdBuffer, 3754 VkBuffer buffer, 3755 platform.VkDeviceSize offset, 3756 VkIndexType indexType) { 3757 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3758 bufferObject := GetBuffer(buffer) 3759 assert(cmdBufferObject.device == bufferObject.device) 3760 3761 bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem) 3762 3763 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3764 cmdBufferObject.queueFlags = queueFlags 3765} 3766 3767@threadSafety("app") 3768cmd void vkCmdBindVertexBuffers( 3769 VkCmdBuffer cmdBuffer, 3770 u32 startBinding, 3771 u32 bindingCount, 3772 const VkBuffer* pBuffers, 3773 const platform.VkDeviceSize* pOffsets) { 3774 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3775 3776 // TODO: check if not [startBinding:startBinding+bindingCount] 3777 buffers := pBuffers[0:bindingCount] 3778 offsets := pOffsets[0:bindingCount] 3779 for i in (0 .. bindingCount) { 3780 buffer := buffers[i] 3781 offset := offsets[i] 3782 bufferObject := GetBuffer(buffer) 3783 assert(cmdBufferObject.device == bufferObject.device) 3784 3785 bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem) 3786 } 3787 3788 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3789 cmdBufferObject.queueFlags = queueFlags 3790} 3791 3792@threadSafety("app") 3793cmd void vkCmdDraw( 3794 VkCmdBuffer cmdBuffer, 3795 u32 firstVertex, 3796 u32 vertexCount, 3797 u32 firstInstance, 3798 u32 instanceCount) { 3799 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3800 3801 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3802 cmdBufferObject.queueFlags = queueFlags 3803} 3804 3805@threadSafety("app") 3806cmd void vkCmdDrawIndexed( 3807 VkCmdBuffer cmdBuffer, 3808 u32 firstIndex, 3809 u32 indexCount, 3810 s32 vertexOffset, 3811 u32 firstInstance, 3812 u32 instanceCount) { 3813 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3814 3815 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3816 cmdBufferObject.queueFlags = queueFlags 3817} 3818 3819@threadSafety("app") 3820cmd void vkCmdDrawIndirect( 3821 VkCmdBuffer cmdBuffer, 3822 VkBuffer buffer, 3823 platform.VkDeviceSize offset, 3824 u32 count, 3825 u32 stride) { 3826 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3827 bufferObject := GetBuffer(buffer) 3828 assert(cmdBufferObject.device == bufferObject.device) 3829 3830 bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem) 3831 3832 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3833 cmdBufferObject.queueFlags = queueFlags 3834} 3835 3836@threadSafety("app") 3837cmd void vkCmdDrawIndexedIndirect( 3838 VkCmdBuffer cmdBuffer, 3839 VkBuffer buffer, 3840 platform.VkDeviceSize offset, 3841 u32 count, 3842 u32 stride) { 3843 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3844 bufferObject := GetBuffer(buffer) 3845 assert(cmdBufferObject.device == bufferObject.device) 3846 3847 bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem) 3848 3849 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3850 cmdBufferObject.queueFlags = queueFlags 3851} 3852 3853@threadSafety("app") 3854cmd void vkCmdDispatch( 3855 VkCmdBuffer cmdBuffer, 3856 u32 x, 3857 u32 y, 3858 u32 z) { 3859 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3860 3861 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_COMPUTE_BIT 3862 cmdBufferObject.queueFlags = queueFlags 3863} 3864 3865@threadSafety("app") 3866cmd void vkCmdDispatchIndirect( 3867 VkCmdBuffer cmdBuffer, 3868 VkBuffer buffer, 3869 platform.VkDeviceSize offset) { 3870 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3871 bufferObject := GetBuffer(buffer) 3872 assert(cmdBufferObject.device == bufferObject.device) 3873 3874 bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem) 3875 3876 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_COMPUTE_BIT 3877 cmdBufferObject.queueFlags = queueFlags 3878} 3879 3880@threadSafety("app") 3881cmd void vkCmdCopyBuffer( 3882 VkCmdBuffer cmdBuffer, 3883 VkBuffer srcBuffer, 3884 VkBuffer destBuffer, 3885 u32 regionCount, 3886 const VkBufferCopy* pRegions) { 3887 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3888 srcBufferObject := GetBuffer(srcBuffer) 3889 destBufferObject := GetBuffer(destBuffer) 3890 assert(cmdBufferObject.device == srcBufferObject.device) 3891 assert(cmdBufferObject.device == destBufferObject.device) 3892 3893 regions := pRegions[0:regionCount] 3894 for i in (0 .. regionCount) { 3895 region := regions[i] 3896 } 3897 3898 bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem) 3899 bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem) 3900 3901 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT 3902 cmdBufferObject.queueFlags = queueFlags 3903} 3904 3905@threadSafety("app") 3906cmd void vkCmdCopyImage( 3907 VkCmdBuffer cmdBuffer, 3908 VkImage srcImage, 3909 VkImageLayout srcImageLayout, 3910 VkImage destImage, 3911 VkImageLayout destImageLayout, 3912 u32 regionCount, 3913 const VkImageCopy* pRegions) { 3914 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3915 srcImageObject := GetImage(srcImage) 3916 destImageObject := GetImage(destImage) 3917 assert(cmdBufferObject.device == srcImageObject.device) 3918 assert(cmdBufferObject.device == destImageObject.device) 3919 3920 regions := pRegions[0:regionCount] 3921 for i in (0 .. regionCount) { 3922 region := regions[i] 3923 } 3924 3925 bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem) 3926 bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem) 3927 3928 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT 3929 cmdBufferObject.queueFlags = queueFlags 3930} 3931 3932@threadSafety("app") 3933cmd void vkCmdBlitImage( 3934 VkCmdBuffer cmdBuffer, 3935 VkImage srcImage, 3936 VkImageLayout srcImageLayout, 3937 VkImage destImage, 3938 VkImageLayout destImageLayout, 3939 u32 regionCount, 3940 const VkImageBlit* pRegions, 3941 VkTexFilter filter) { 3942 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3943 srcImageObject := GetImage(srcImage) 3944 destImageObject := GetImage(destImage) 3945 assert(cmdBufferObject.device == srcImageObject.device) 3946 assert(cmdBufferObject.device == destImageObject.device) 3947 3948 regions := pRegions[0:regionCount] 3949 for i in (0 .. regionCount) { 3950 region := regions[i] 3951 } 3952 3953 bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem) 3954 bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem) 3955 3956 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 3957 cmdBufferObject.queueFlags = queueFlags 3958} 3959 3960@threadSafety("app") 3961cmd void vkCmdCopyBufferToImage( 3962 VkCmdBuffer cmdBuffer, 3963 VkBuffer srcBuffer, 3964 VkImage destImage, 3965 VkImageLayout destImageLayout, 3966 u32 regionCount, 3967 const VkBufferImageCopy* pRegions) { 3968 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3969 srcBufferObject := GetBuffer(srcBuffer) 3970 destImageObject := GetImage(destImage) 3971 assert(cmdBufferObject.device == srcBufferObject.device) 3972 assert(cmdBufferObject.device == destImageObject.device) 3973 3974 regions := pRegions[0:regionCount] 3975 for i in (0 .. regionCount) { 3976 region := regions[i] 3977 } 3978 3979 bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem) 3980 bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem) 3981 3982 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT 3983 cmdBufferObject.queueFlags = queueFlags 3984} 3985 3986@threadSafety("app") 3987cmd void vkCmdCopyImageToBuffer( 3988 VkCmdBuffer cmdBuffer, 3989 VkImage srcImage, 3990 VkImageLayout srcImageLayout, 3991 VkBuffer destBuffer, 3992 u32 regionCount, 3993 const VkBufferImageCopy* pRegions) { 3994 cmdBufferObject := GetCmdBuffer(cmdBuffer) 3995 srcImageObject := GetImage(srcImage) 3996 destBufferObject := GetBuffer(destBuffer) 3997 assert(cmdBufferObject.device == srcImageObject.device) 3998 assert(cmdBufferObject.device == destBufferObject.device) 3999 4000 regions := pRegions[0:regionCount] 4001 for i in (0 .. regionCount) { 4002 region := regions[i] 4003 } 4004 4005 bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem) 4006 bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem) 4007 4008 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT 4009 cmdBufferObject.queueFlags = queueFlags 4010} 4011 4012@threadSafety("app") 4013cmd void vkCmdUpdateBuffer( 4014 VkCmdBuffer cmdBuffer, 4015 VkBuffer destBuffer, 4016 platform.VkDeviceSize destOffset, 4017 platform.VkDeviceSize dataSize, 4018 const u32* pData) { 4019 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4020 destBufferObject := GetBuffer(destBuffer) 4021 assert(cmdBufferObject.device == destBufferObject.device) 4022 4023 data := pData[0:dataSize] 4024 4025 bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem) 4026 4027 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT 4028 cmdBufferObject.queueFlags = queueFlags 4029} 4030 4031@threadSafety("app") 4032cmd void vkCmdFillBuffer( 4033 VkCmdBuffer cmdBuffer, 4034 VkBuffer destBuffer, 4035 platform.VkDeviceSize destOffset, 4036 platform.VkDeviceSize fillSize, 4037 u32 data) { 4038 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4039 destBufferObject := GetBuffer(destBuffer) 4040 assert(cmdBufferObject.device == destBufferObject.device) 4041 4042 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT 4043 cmdBufferObject.queueFlags = queueFlags 4044} 4045 4046@threadSafety("app") 4047cmd void vkCmdClearColorImage( 4048 VkCmdBuffer cmdBuffer, 4049 VkImage image, 4050 VkImageLayout imageLayout, 4051 const VkClearColorValue* pColor, 4052 u32 rangeCount, 4053 const VkImageSubresourceRange* pRanges) { 4054 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4055 imageObject := GetImage(image) 4056 assert(cmdBufferObject.device == imageObject.device) 4057 4058 ranges := pRanges[0:rangeCount] 4059 for i in (0 .. rangeCount) { 4060 range := ranges[i] 4061 } 4062 4063 bindCmdBuffer(cmdBuffer, image, imageObject.mem) 4064 4065 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4066 cmdBufferObject.queueFlags = queueFlags 4067} 4068 4069@threadSafety("app") 4070cmd void vkCmdClearDepthStencilImage( 4071 VkCmdBuffer cmdBuffer, 4072 VkImage image, 4073 VkImageLayout imageLayout, 4074 f32 depth, 4075 u32 stencil, 4076 u32 rangeCount, 4077 const VkImageSubresourceRange* pRanges) { 4078 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4079 imageObject := GetImage(image) 4080 assert(cmdBufferObject.device == imageObject.device) 4081 4082 ranges := pRanges[0:rangeCount] 4083 for i in (0 .. rangeCount) { 4084 range := ranges[i] 4085 } 4086 4087 bindCmdBuffer(cmdBuffer, image, imageObject.mem) 4088 4089 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4090 cmdBufferObject.queueFlags = queueFlags 4091} 4092 4093@threadSafety("app") 4094cmd void vkCmdClearColorAttachment( 4095 VkCmdBuffer cmdBuffer, 4096 u32 colorAttachment, 4097 VkImageLayout imageLayout, 4098 const VkClearColorValue* pColor, 4099 u32 rectCount, 4100 const VkRect3D* pRects) { 4101 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4102 4103 rects := pRects[0:rectCount] 4104 for i in (0 .. rectCount) { 4105 rect := rects[i] 4106 } 4107 4108 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4109 cmdBufferObject.queueFlags = queueFlags 4110} 4111 4112@threadSafety("app") 4113cmd void vkCmdClearDepthStencilAttachment( 4114 VkCmdBuffer cmdBuffer, 4115 VkImageAspectFlags imageAspectMask, 4116 VkImageLayout imageLayout, 4117 f32 depth, 4118 u32 stencil, 4119 u32 rectCount, 4120 const VkRect3D* pRects) { 4121 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4122 4123 rects := pRects[0:rectCount] 4124 for i in (0 .. rectCount) { 4125 rect := rects[i] 4126 } 4127 4128 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4129 cmdBufferObject.queueFlags = queueFlags 4130} 4131 4132@threadSafety("app") 4133cmd void vkCmdResolveImage( 4134 VkCmdBuffer cmdBuffer, 4135 VkImage srcImage, 4136 VkImageLayout srcImageLayout, 4137 VkImage destImage, 4138 VkImageLayout destImageLayout, 4139 u32 regionCount, 4140 const VkImageResolve* pRegions) { 4141 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4142 srcImageObject := GetImage(srcImage) 4143 destImageObject := GetImage(destImage) 4144 assert(cmdBufferObject.device == srcImageObject.device) 4145 assert(cmdBufferObject.device == destImageObject.device) 4146 4147 regions := pRegions[0:regionCount] 4148 for i in (0 .. regionCount) { 4149 region := regions[i] 4150 } 4151 4152 bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem) 4153 bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem) 4154 4155 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4156 cmdBufferObject.queueFlags = queueFlags 4157} 4158 4159@threadSafety("app") 4160cmd void vkCmdSetEvent( 4161 VkCmdBuffer cmdBuffer, 4162 VkEvent event, 4163 VkPipelineStageFlags stageMask) { 4164 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4165 eventObject := GetEvent(event) 4166 assert(cmdBufferObject.device == eventObject.device) 4167} 4168 4169@threadSafety("app") 4170cmd void vkCmdResetEvent( 4171 VkCmdBuffer cmdBuffer, 4172 VkEvent event, 4173 VkPipelineStageFlags stageMask) { 4174 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4175 eventObject := GetEvent(event) 4176 assert(cmdBufferObject.device == eventObject.device) 4177} 4178 4179@threadSafety("app") 4180cmd void vkCmdWaitEvents( 4181 VkCmdBuffer cmdBuffer, 4182 u32 eventCount, 4183 const VkEvent* pEvents, 4184 VkPipelineStageFlags srcStageMask, 4185 VkPipelineStageFlags destStageMask, 4186 u32 memBarrierCount, 4187 const void* const* ppMemBarriers) { 4188 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4189 4190 events := pEvents[0:eventCount] 4191 for i in (0 .. eventCount) { 4192 event := events[i] 4193 eventObject := GetEvent(event) 4194 assert(cmdBufferObject.device == eventObject.device) 4195 } 4196 4197 pMemBarriers := ppMemBarriers[0:memBarrierCount] 4198 for i in (0 .. memBarrierCount) { 4199 switch as!VkMemoryBarrier const*(pMemBarriers[i])[0].sType { 4200 case VK_STRUCTURE_TYPE_MEMORY_BARRIER: { 4201 memBarrier := as!VkMemoryBarrier const*(pMemBarriers[i])[0] 4202 } 4203 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: { 4204 imageMemBarrier := as!VkImageMemoryBarrier const*(pMemBarriers[i])[0] 4205 imageObject := GetImage(imageMemBarrier.image) 4206 assert(imageObject.device == cmdBufferObject.device) 4207 } 4208 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: { 4209 bufferMemBarrier := as!VkBufferMemoryBarrier const*(pMemBarriers[i])[0] 4210 bufferObject := GetBuffer(bufferMemBarrier.buffer) 4211 assert(bufferObject.device == cmdBufferObject.device) 4212 } 4213 } 4214 } 4215} 4216 4217@threadSafety("app") 4218cmd void vkCmdPipelineBarrier( 4219 VkCmdBuffer cmdBuffer, 4220 VkPipelineStageFlags srcStageMask, 4221 VkPipelineStageFlags destStageMask, 4222 platform.VkBool32 byRegion, 4223 u32 memBarrierCount, 4224 const void* const* ppMemBarriers) { 4225 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4226 4227 pMemBarriers := ppMemBarriers[0:memBarrierCount] 4228 for i in (0 .. memBarrierCount) { 4229 switch as!VkMemoryBarrier const*(pMemBarriers[i])[0].sType { 4230 case VK_STRUCTURE_TYPE_MEMORY_BARRIER: { 4231 memBarrier := as!VkMemoryBarrier const*(pMemBarriers[i])[0] 4232 } 4233 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: { 4234 imageMemBarrier := as!VkImageMemoryBarrier const*(pMemBarriers[i])[0] 4235 imageObject := GetImage(imageMemBarrier.image) 4236 assert(imageObject.device == cmdBufferObject.device) 4237 } 4238 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: { 4239 bufferMemBarrier := as!VkBufferMemoryBarrier const*(pMemBarriers[i])[0] 4240 bufferObject := GetBuffer(bufferMemBarrier.buffer) 4241 assert(bufferObject.device == cmdBufferObject.device) 4242 } 4243 } 4244 } 4245} 4246 4247@threadSafety("app") 4248cmd void vkCmdBeginQuery( 4249 VkCmdBuffer cmdBuffer, 4250 VkQueryPool queryPool, 4251 u32 slot, 4252 VkQueryControlFlags flags) { 4253 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4254 queryPoolObject := GetQueryPool(queryPool) 4255 assert(cmdBufferObject.device == queryPoolObject.device) 4256} 4257 4258@threadSafety("app") 4259cmd void vkCmdEndQuery( 4260 VkCmdBuffer cmdBuffer, 4261 VkQueryPool queryPool, 4262 u32 slot) { 4263 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4264 queryPoolObject := GetQueryPool(queryPool) 4265 assert(cmdBufferObject.device == queryPoolObject.device) 4266} 4267 4268@threadSafety("app") 4269cmd void vkCmdResetQueryPool( 4270 VkCmdBuffer cmdBuffer, 4271 VkQueryPool queryPool, 4272 u32 startQuery, 4273 u32 queryCount) { 4274 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4275 queryPoolObject := GetQueryPool(queryPool) 4276 assert(cmdBufferObject.device == queryPoolObject.device) 4277} 4278 4279@threadSafety("app") 4280cmd void vkCmdWriteTimestamp( 4281 VkCmdBuffer cmdBuffer, 4282 VkTimestampType timestampType, 4283 VkBuffer destBuffer, 4284 platform.VkDeviceSize destOffset) { 4285 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4286 destBufferObject := GetBuffer(destBuffer) 4287 assert(cmdBufferObject.device == destBufferObject.device) 4288} 4289 4290@threadSafety("app") 4291cmd void vkCmdCopyQueryPoolResults( 4292 VkCmdBuffer cmdBuffer, 4293 VkQueryPool queryPool, 4294 u32 startQuery, 4295 u32 queryCount, 4296 VkBuffer destBuffer, 4297 platform.VkDeviceSize destOffset, 4298 platform.VkDeviceSize destStride, 4299 VkQueryResultFlags flags) { 4300 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4301 queryPoolObject := GetQueryPool(queryPool) 4302 destBufferObject := GetBuffer(destBuffer) 4303 assert(cmdBufferObject.device == queryPoolObject.device) 4304 assert(cmdBufferObject.device == destBufferObject.device) 4305} 4306 4307cmd void vkCmdPushConstants( 4308 VkCmdBuffer cmdBuffer, 4309 VkPipelineLayout layout, 4310 VkShaderStageFlags stageFlags, 4311 u32 start, 4312 u32 length, 4313 const void* values) { 4314 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4315 layoutObject := GetPipelineLayout(layout) 4316 assert(cmdBufferObject.device == layoutObject.device) 4317} 4318 4319@threadSafety("app") 4320cmd void vkCmdBeginRenderPass( 4321 VkCmdBuffer cmdBuffer, 4322 const VkRenderPassBeginInfo* pRenderPassBegin, 4323 VkRenderPassContents contents) { 4324 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4325 renderPassObject := GetRenderPass(pRenderPassBegin.renderPass) 4326 framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer) 4327 assert(cmdBufferObject.device == renderPassObject.device) 4328 assert(cmdBufferObject.device == framebufferObject.device) 4329 4330 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4331 cmdBufferObject.queueFlags = queueFlags 4332} 4333 4334cmd void vkCmdNextSubpass( 4335 VkCmdBuffer cmdBuffer, 4336 VkRenderPassContents contents) { 4337 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4338} 4339 4340@threadSafety("app") 4341cmd void vkCmdEndRenderPass( 4342 VkCmdBuffer cmdBuffer) { 4343 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4344 4345 queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT 4346 cmdBufferObject.queueFlags = queueFlags 4347} 4348 4349cmd void vkCmdExecuteCommands( 4350 VkCmdBuffer cmdBuffer, 4351 u32 cmdBuffersCount, 4352 const VkCmdBuffer* pCmdBuffers) { 4353 cmdBufferObject := GetCmdBuffer(cmdBuffer) 4354 4355 cmdBuffers := pCmdBuffers[0:cmdBuffersCount] 4356 for i in (0 .. cmdBuffersCount) { 4357 secondaryCmdBuffer := cmdBuffers[i] 4358 secondaryCmdBufferObject := GetCmdBuffer(secondaryCmdBuffer) 4359 assert(cmdBufferObject.device == secondaryCmdBufferObject.device) 4360 } 4361} 4362 4363 4364//////////////// 4365// Validation // 4366//////////////// 4367 4368extern void validate(string layerName, bool condition, string message) 4369 4370 4371///////////////////////////// 4372// Internal State Tracking // 4373///////////////////////////// 4374 4375StateObject State 4376 4377@internal class StateObject { 4378 // Dispatchable objects. 4379 map!(VkInstance, ref!InstanceObject) Instances 4380 map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices 4381 map!(VkDevice, ref!DeviceObject) Devices 4382 map!(VkQueue, ref!QueueObject) Queues 4383 map!(VkCmdBuffer, ref!CmdBufferObject) CmdBuffers 4384 4385 // Non-dispatchable objects. 4386 map!(VkDeviceMemory, ref!DeviceMemoryObject) DeviceMemories 4387 map!(VkBuffer, ref!BufferObject) Buffers 4388 map!(VkBufferView, ref!BufferViewObject) BufferViews 4389 map!(VkImage, ref!ImageObject) Images 4390 map!(VkImageView, ref!ImageViewObject) ImageViews 4391 map!(VkAttachmentView, ref!AttachmentViewObject) AttachmentViews 4392 map!(VkShaderModule, ref!ShaderModuleObject) ShaderModules 4393 map!(VkShader, ref!ShaderObject) Shaders 4394 map!(VkPipeline, ref!PipelineObject) Pipelines 4395 map!(VkPipelineLayout, ref!PipelineLayoutObject) PipelineLayouts 4396 map!(VkSampler, ref!SamplerObject) Samplers 4397 map!(VkDescriptorSet, ref!DescriptorSetObject) DescriptorSets 4398 map!(VkDescriptorSetLayout, ref!DescriptorSetLayoutObject) DescriptorSetLayouts 4399 map!(VkDescriptorPool, ref!DescriptorPoolObject) DescriptorPools 4400 map!(VkDynamicViewportState, ref!DynamicViewportStateObject) DynamicViewportStates 4401 map!(VkDynamicRasterState, ref!DynamicRasterStateObject) DynamicRasterStates 4402 map!(VkDynamicColorBlendState, ref!DynamicColorBlendStateObject) DynamicColorBlendStates 4403 map!(VkDynamicDepthStencilState, ref!DynamicDepthStencilStateObject) DynamicDepthStencilStates 4404 map!(VkFence, ref!FenceObject) Fences 4405 map!(VkSemaphore, ref!SemaphoreObject) Semaphores 4406 map!(VkEvent, ref!EventObject) Events 4407 map!(VkQueryPool, ref!QueryPoolObject) QueryPools 4408 map!(VkFramebuffer, ref!FramebufferObject) Framebuffers 4409 map!(VkRenderPass, ref!RenderPassObject) RenderPasses 4410 map!(VkPipelineCache, ref!PipelineCacheObject) PipelineCaches 4411 map!(VkCmdPool, ref!CmdPoolObject) CmdPools 4412} 4413 4414@internal class InstanceObject { 4415} 4416 4417@internal class PhysicalDeviceObject { 4418 VkInstance instance 4419} 4420 4421@internal class DeviceObject { 4422 VkPhysicalDevice physicalDevice 4423} 4424 4425@internal class QueueObject { 4426 VkDevice device 4427 VkQueueFlags flags 4428} 4429 4430@internal class CmdBufferObject { 4431 VkDevice device 4432 map!(u64, VkDeviceMemory) boundObjects 4433 VkQueueFlags queueFlags 4434} 4435 4436@internal class DeviceMemoryObject { 4437 VkDevice device 4438 platform.VkDeviceSize allocationSize 4439 map!(u64, platform.VkDeviceSize) boundObjects 4440 map!(VkCmdBuffer, VkCmdBuffer) boundCommandBuffers 4441} 4442 4443@internal class BufferObject { 4444 VkDevice device 4445 VkDeviceMemory mem 4446 platform.VkDeviceSize memOffset 4447} 4448 4449@internal class BufferViewObject { 4450 VkDevice device 4451 VkBuffer buffer 4452} 4453 4454@internal class ImageObject { 4455 VkDevice device 4456 VkDeviceMemory mem 4457 platform.VkDeviceSize memOffset 4458} 4459 4460@internal class ImageViewObject { 4461 VkDevice device 4462 VkImage image 4463} 4464 4465@internal class AttachmentViewObject { 4466 VkDevice device 4467 VkImage image 4468} 4469 4470@internal class ShaderObject { 4471 VkDevice device 4472} 4473 4474@internal class ShaderModuleObject { 4475 VkDevice device 4476} 4477 4478@internal class PipelineObject { 4479 VkDevice device 4480} 4481 4482@internal class PipelineLayoutObject { 4483 VkDevice device 4484} 4485 4486@internal class SamplerObject { 4487 VkDevice device 4488} 4489 4490@internal class DescriptorSetObject { 4491 VkDevice device 4492} 4493 4494@internal class DescriptorSetLayoutObject { 4495 VkDevice device 4496} 4497 4498@internal class DescriptorPoolObject { 4499 VkDevice device 4500} 4501 4502@internal class DynamicViewportStateObject { 4503 VkDevice device 4504} 4505 4506@internal class DynamicRasterStateObject { 4507 VkDevice device 4508} 4509 4510@internal class DynamicColorBlendStateObject { 4511 VkDevice device 4512} 4513 4514@internal class DynamicDepthStencilStateObject { 4515 VkDevice device 4516} 4517 4518@internal class FenceObject { 4519 VkDevice device 4520 bool signaled 4521} 4522 4523@internal class SemaphoreObject { 4524 VkDevice device 4525} 4526 4527@internal class EventObject { 4528 VkDevice device 4529} 4530 4531@internal class QueryPoolObject { 4532 VkDevice device 4533} 4534 4535@internal class FramebufferObject { 4536 VkDevice device 4537} 4538 4539@internal class RenderPassObject { 4540 VkDevice device 4541} 4542 4543@internal class PipelineCacheObject { 4544 VkDevice device 4545} 4546 4547@internal class CmdPoolObject { 4548 VkDevice device 4549} 4550 4551macro ref!InstanceObject GetInstance(VkInstance instance) { 4552 assert(instance in State.Instances) 4553 return State.Instances[instance] 4554} 4555 4556macro ref!PhysicalDeviceObject GetPhysicalDevice(VkPhysicalDevice physicalDevice) { 4557 assert(physicalDevice in State.PhysicalDevices) 4558 return State.PhysicalDevices[physicalDevice] 4559} 4560 4561macro ref!DeviceObject GetDevice(VkDevice device) { 4562 assert(device in State.Devices) 4563 return State.Devices[device] 4564} 4565 4566macro ref!QueueObject GetQueue(VkQueue queue) { 4567 assert(queue in State.Queues) 4568 return State.Queues[queue] 4569} 4570 4571macro ref!CmdBufferObject GetCmdBuffer(VkCmdBuffer cmdBuffer) { 4572 assert(cmdBuffer in State.CmdBuffers) 4573 return State.CmdBuffers[cmdBuffer] 4574} 4575 4576macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory mem) { 4577 assert(mem in State.DeviceMemories) 4578 return State.DeviceMemories[mem] 4579} 4580 4581macro ref!BufferObject GetBuffer(VkBuffer buffer) { 4582 assert(buffer in State.Buffers) 4583 return State.Buffers[buffer] 4584} 4585 4586macro ref!BufferViewObject GetBufferView(VkBufferView bufferView) { 4587 assert(bufferView in State.BufferViews) 4588 return State.BufferViews[bufferView] 4589} 4590 4591macro ref!ImageObject GetImage(VkImage image) { 4592 assert(image in State.Images) 4593 return State.Images[image] 4594} 4595 4596macro ref!ImageViewObject GetImageView(VkImageView imageView) { 4597 assert(imageView in State.ImageViews) 4598 return State.ImageViews[imageView] 4599} 4600 4601macro ref!AttachmentViewObject GetAttachmentView(VkAttachmentView attachmentView) { 4602 assert(attachmentView in State.AttachmentViews) 4603 return State.AttachmentViews[attachmentView] 4604} 4605 4606macro ref!ShaderObject GetShader(VkShader shader) { 4607 assert(shader in State.Shaders) 4608 return State.Shaders[shader] 4609} 4610 4611macro ref!ShaderModuleObject GetShaderModule(VkShaderModule shaderModule) { 4612 assert(shaderModule in State.ShaderModules) 4613 return State.ShaderModules[shaderModule] 4614} 4615 4616macro ref!PipelineObject GetPipeline(VkPipeline pipeline) { 4617 assert(pipeline in State.Pipelines) 4618 return State.Pipelines[pipeline] 4619} 4620 4621macro ref!PipelineLayoutObject GetPipelineLayout(VkPipelineLayout pipelineLayout) { 4622 assert(pipelineLayout in State.PipelineLayouts) 4623 return State.PipelineLayouts[pipelineLayout] 4624} 4625 4626macro ref!SamplerObject GetSampler(VkSampler sampler) { 4627 assert(sampler in State.Samplers) 4628 return State.Samplers[sampler] 4629} 4630 4631macro ref!DescriptorSetObject GetDescriptorSet(VkDescriptorSet descriptorSet) { 4632 assert(descriptorSet in State.DescriptorSets) 4633 return State.DescriptorSets[descriptorSet] 4634} 4635 4636macro ref!DescriptorSetLayoutObject GetDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) { 4637 assert(descriptorSetLayout in State.DescriptorSetLayouts) 4638 return State.DescriptorSetLayouts[descriptorSetLayout] 4639} 4640 4641macro ref!DescriptorPoolObject GetDescriptorPool(VkDescriptorPool descriptorPool) { 4642 assert(descriptorPool in State.DescriptorPools) 4643 return State.DescriptorPools[descriptorPool] 4644} 4645 4646macro ref!DynamicViewportStateObject GetDynamicViewportState(VkDynamicViewportState dynamicViewportState) { 4647 assert(dynamicViewportState in State.DynamicViewportStates) 4648 return State.DynamicViewportStates[dynamicViewportState] 4649} 4650 4651macro ref!DynamicRasterStateObject GetDynamicRasterState(VkDynamicRasterState dynamicRasterState) { 4652 assert(dynamicRasterState in State.DynamicRasterStates) 4653 return State.DynamicRasterStates[dynamicRasterState] 4654} 4655 4656macro ref!DynamicColorBlendStateObject GetDynamicColorBlendState(VkDynamicColorBlendState dynamicColorBlendState) { 4657 assert(dynamicColorBlendState in State.DynamicColorBlendStates) 4658 return State.DynamicColorBlendStates[dynamicColorBlendState] 4659} 4660 4661macro ref!DynamicDepthStencilStateObject GetDynamicDepthStencilState(VkDynamicDepthStencilState dynamicDepthStencilState) { 4662 assert(dynamicDepthStencilState in State.DynamicDepthStencilStates) 4663 return State.DynamicDepthStencilStates[dynamicDepthStencilState] 4664} 4665 4666macro ref!FenceObject GetFence(VkFence fence) { 4667 assert(fence in State.Fences) 4668 return State.Fences[fence] 4669} 4670 4671macro ref!SemaphoreObject GetSemaphore(VkSemaphore semaphore) { 4672 assert(semaphore in State.Semaphores) 4673 return State.Semaphores[semaphore] 4674} 4675 4676macro ref!EventObject GetEvent(VkEvent event) { 4677 assert(event in State.Events) 4678 return State.Events[event] 4679} 4680 4681macro ref!QueryPoolObject GetQueryPool(VkQueryPool queryPool) { 4682 assert(queryPool in State.QueryPools) 4683 return State.QueryPools[queryPool] 4684} 4685 4686macro ref!FramebufferObject GetFramebuffer(VkFramebuffer framebuffer) { 4687 assert(framebuffer in State.Framebuffers) 4688 return State.Framebuffers[framebuffer] 4689} 4690 4691macro ref!RenderPassObject GetRenderPass(VkRenderPass renderPass) { 4692 assert(renderPass in State.RenderPasses) 4693 return State.RenderPasses[renderPass] 4694} 4695 4696macro ref!PipelineCacheObject GetPipelineCache(VkPipelineCache pipelineCache) { 4697 assert(pipelineCache in State.PipelineCaches) 4698 return State.PipelineCaches[pipelineCache] 4699} 4700 4701macro ref!CmdPoolObject GetCmdPool(VkCmdPool cmdPool) { 4702 assert(cmdPool in State.CmdPools) 4703 return State.CmdPools[cmdPool] 4704}