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