1 /* This file is generated by venus-protocol. See vn_protocol_driver.h. */ 2 3 /* 4 * Copyright 2020 Google LLC 5 * SPDX-License-Identifier: MIT 6 */ 7 8 #ifndef VN_PROTOCOL_DRIVER_IMAGE_H 9 #define VN_PROTOCOL_DRIVER_IMAGE_H 10 11 #include "vn_instance.h" 12 #include "vn_protocol_driver_structs.h" 13 14 /* struct VkSparseImageMemoryRequirements */ 15 16 static inline size_t 17 vn_sizeof_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements *val) 18 { 19 size_t size = 0; 20 size += vn_sizeof_VkSparseImageFormatProperties(&val->formatProperties); 21 size += vn_sizeof_uint32_t(&val->imageMipTailFirstLod); 22 size += vn_sizeof_VkDeviceSize(&val->imageMipTailSize); 23 size += vn_sizeof_VkDeviceSize(&val->imageMipTailOffset); 24 size += vn_sizeof_VkDeviceSize(&val->imageMipTailStride); 25 return size; 26 } 27 28 static inline void 29 vn_decode_VkSparseImageMemoryRequirements(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements *val) 30 { 31 vn_decode_VkSparseImageFormatProperties(dec, &val->formatProperties); 32 vn_decode_uint32_t(dec, &val->imageMipTailFirstLod); 33 vn_decode_VkDeviceSize(dec, &val->imageMipTailSize); 34 vn_decode_VkDeviceSize(dec, &val->imageMipTailOffset); 35 vn_decode_VkDeviceSize(dec, &val->imageMipTailStride); 36 } 37 38 static inline size_t 39 vn_sizeof_VkSparseImageMemoryRequirements_partial(const VkSparseImageMemoryRequirements *val) 40 { 41 size_t size = 0; 42 size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->formatProperties); 43 /* skip val->imageMipTailFirstLod */ 44 /* skip val->imageMipTailSize */ 45 /* skip val->imageMipTailOffset */ 46 /* skip val->imageMipTailStride */ 47 return size; 48 } 49 50 static inline void 51 vn_encode_VkSparseImageMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements *val) 52 { 53 vn_encode_VkSparseImageFormatProperties_partial(enc, &val->formatProperties); 54 /* skip val->imageMipTailFirstLod */ 55 /* skip val->imageMipTailSize */ 56 /* skip val->imageMipTailOffset */ 57 /* skip val->imageMipTailStride */ 58 } 59 60 /* struct VkExternalMemoryImageCreateInfo chain */ 61 62 static inline size_t 63 vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void *val) 64 { 65 /* no known/supported struct */ 66 return vn_sizeof_simple_pointer(NULL); 67 } 68 69 static inline size_t 70 vn_sizeof_VkExternalMemoryImageCreateInfo_self(const VkExternalMemoryImageCreateInfo *val) 71 { 72 size_t size = 0; 73 /* skip val->{sType,pNext} */ 74 size += vn_sizeof_VkFlags(&val->handleTypes); 75 return size; 76 } 77 78 static inline size_t 79 vn_sizeof_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo *val) 80 { 81 size_t size = 0; 82 83 size += vn_sizeof_VkStructureType(&val->sType); 84 size += vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(val->pNext); 85 size += vn_sizeof_VkExternalMemoryImageCreateInfo_self(val); 86 87 return size; 88 } 89 90 static inline void 91 vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) 92 { 93 /* no known/supported struct */ 94 vn_encode_simple_pointer(enc, NULL); 95 } 96 97 static inline void 98 vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val) 99 { 100 /* skip val->{sType,pNext} */ 101 vn_encode_VkFlags(enc, &val->handleTypes); 102 } 103 104 static inline void 105 vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val) 106 { 107 assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO); 108 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO }); 109 vn_encode_VkExternalMemoryImageCreateInfo_pnext(enc, val->pNext); 110 vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val); 111 } 112 113 /* struct VkImageDrmFormatModifierListCreateInfoEXT chain */ 114 115 static inline size_t 116 vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void *val) 117 { 118 /* no known/supported struct */ 119 return vn_sizeof_simple_pointer(NULL); 120 } 121 122 static inline size_t 123 vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(const VkImageDrmFormatModifierListCreateInfoEXT *val) 124 { 125 size_t size = 0; 126 /* skip val->{sType,pNext} */ 127 size += vn_sizeof_uint32_t(&val->drmFormatModifierCount); 128 if (val->pDrmFormatModifiers) { 129 size += vn_sizeof_array_size(val->drmFormatModifierCount); 130 size += vn_sizeof_uint64_t_array(val->pDrmFormatModifiers, val->drmFormatModifierCount); 131 } else { 132 size += vn_sizeof_array_size(0); 133 } 134 return size; 135 } 136 137 static inline size_t 138 vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT *val) 139 { 140 size_t size = 0; 141 142 size += vn_sizeof_VkStructureType(&val->sType); 143 size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(val->pNext); 144 size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(val); 145 146 return size; 147 } 148 149 static inline void 150 vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val) 151 { 152 /* no known/supported struct */ 153 vn_encode_simple_pointer(enc, NULL); 154 } 155 156 static inline void 157 vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val) 158 { 159 /* skip val->{sType,pNext} */ 160 vn_encode_uint32_t(enc, &val->drmFormatModifierCount); 161 if (val->pDrmFormatModifiers) { 162 vn_encode_array_size(enc, val->drmFormatModifierCount); 163 vn_encode_uint64_t_array(enc, val->pDrmFormatModifiers, val->drmFormatModifierCount); 164 } else { 165 vn_encode_array_size(enc, 0); 166 } 167 } 168 169 static inline void 170 vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val) 171 { 172 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT); 173 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT }); 174 vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(enc, val->pNext); 175 vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val); 176 } 177 178 /* struct VkSubresourceLayout */ 179 180 static inline size_t 181 vn_sizeof_VkSubresourceLayout(const VkSubresourceLayout *val) 182 { 183 size_t size = 0; 184 size += vn_sizeof_VkDeviceSize(&val->offset); 185 size += vn_sizeof_VkDeviceSize(&val->size); 186 size += vn_sizeof_VkDeviceSize(&val->rowPitch); 187 size += vn_sizeof_VkDeviceSize(&val->arrayPitch); 188 size += vn_sizeof_VkDeviceSize(&val->depthPitch); 189 return size; 190 } 191 192 static inline void 193 vn_encode_VkSubresourceLayout(struct vn_cs_encoder *enc, const VkSubresourceLayout *val) 194 { 195 vn_encode_VkDeviceSize(enc, &val->offset); 196 vn_encode_VkDeviceSize(enc, &val->size); 197 vn_encode_VkDeviceSize(enc, &val->rowPitch); 198 vn_encode_VkDeviceSize(enc, &val->arrayPitch); 199 vn_encode_VkDeviceSize(enc, &val->depthPitch); 200 } 201 202 static inline void 203 vn_decode_VkSubresourceLayout(struct vn_cs_decoder *dec, VkSubresourceLayout *val) 204 { 205 vn_decode_VkDeviceSize(dec, &val->offset); 206 vn_decode_VkDeviceSize(dec, &val->size); 207 vn_decode_VkDeviceSize(dec, &val->rowPitch); 208 vn_decode_VkDeviceSize(dec, &val->arrayPitch); 209 vn_decode_VkDeviceSize(dec, &val->depthPitch); 210 } 211 212 static inline size_t 213 vn_sizeof_VkSubresourceLayout_partial(const VkSubresourceLayout *val) 214 { 215 size_t size = 0; 216 /* skip val->offset */ 217 /* skip val->size */ 218 /* skip val->rowPitch */ 219 /* skip val->arrayPitch */ 220 /* skip val->depthPitch */ 221 return size; 222 } 223 224 static inline void 225 vn_encode_VkSubresourceLayout_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout *val) 226 { 227 /* skip val->offset */ 228 /* skip val->size */ 229 /* skip val->rowPitch */ 230 /* skip val->arrayPitch */ 231 /* skip val->depthPitch */ 232 } 233 234 /* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */ 235 236 static inline size_t 237 vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void *val) 238 { 239 /* no known/supported struct */ 240 return vn_sizeof_simple_pointer(NULL); 241 } 242 243 static inline size_t 244 vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) 245 { 246 size_t size = 0; 247 /* skip val->{sType,pNext} */ 248 size += vn_sizeof_uint64_t(&val->drmFormatModifier); 249 size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount); 250 if (val->pPlaneLayouts) { 251 size += vn_sizeof_array_size(val->drmFormatModifierPlaneCount); 252 for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++) 253 size += vn_sizeof_VkSubresourceLayout(&val->pPlaneLayouts[i]); 254 } else { 255 size += vn_sizeof_array_size(0); 256 } 257 return size; 258 } 259 260 static inline size_t 261 vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) 262 { 263 size_t size = 0; 264 265 size += vn_sizeof_VkStructureType(&val->sType); 266 size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(val->pNext); 267 size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(val); 268 269 return size; 270 } 271 272 static inline void 273 vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val) 274 { 275 /* no known/supported struct */ 276 vn_encode_simple_pointer(enc, NULL); 277 } 278 279 static inline void 280 vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) 281 { 282 /* skip val->{sType,pNext} */ 283 vn_encode_uint64_t(enc, &val->drmFormatModifier); 284 vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount); 285 if (val->pPlaneLayouts) { 286 vn_encode_array_size(enc, val->drmFormatModifierPlaneCount); 287 for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++) 288 vn_encode_VkSubresourceLayout(enc, &val->pPlaneLayouts[i]); 289 } else { 290 vn_encode_array_size(enc, 0); 291 } 292 } 293 294 static inline void 295 vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) 296 { 297 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT); 298 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT }); 299 vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(enc, val->pNext); 300 vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val); 301 } 302 303 /* struct VkImageCreateInfo chain */ 304 305 static inline size_t 306 vn_sizeof_VkImageCreateInfo_pnext(const void *val) 307 { 308 const VkBaseInStructure *pnext = val; 309 size_t size = 0; 310 311 while (pnext) { 312 switch ((int32_t)pnext->sType) { 313 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: 314 size += vn_sizeof_simple_pointer(pnext); 315 size += vn_sizeof_VkStructureType(&pnext->sType); 316 size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); 317 size += vn_sizeof_VkExternalMemoryImageCreateInfo_self((const VkExternalMemoryImageCreateInfo *)pnext); 318 return size; 319 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: 320 size += vn_sizeof_simple_pointer(pnext); 321 size += vn_sizeof_VkStructureType(&pnext->sType); 322 size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); 323 size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext); 324 return size; 325 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: 326 size += vn_sizeof_simple_pointer(pnext); 327 size += vn_sizeof_VkStructureType(&pnext->sType); 328 size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); 329 size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self((const VkImageDrmFormatModifierListCreateInfoEXT *)pnext); 330 return size; 331 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: 332 size += vn_sizeof_simple_pointer(pnext); 333 size += vn_sizeof_VkStructureType(&pnext->sType); 334 size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); 335 size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self((const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext); 336 return size; 337 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: 338 size += vn_sizeof_simple_pointer(pnext); 339 size += vn_sizeof_VkStructureType(&pnext->sType); 340 size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); 341 size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext); 342 return size; 343 default: 344 /* ignore unknown/unsupported struct */ 345 break; 346 } 347 pnext = pnext->pNext; 348 } 349 350 return vn_sizeof_simple_pointer(NULL); 351 } 352 353 static inline size_t 354 vn_sizeof_VkImageCreateInfo_self(const VkImageCreateInfo *val) 355 { 356 size_t size = 0; 357 /* skip val->{sType,pNext} */ 358 size += vn_sizeof_VkFlags(&val->flags); 359 size += vn_sizeof_VkImageType(&val->imageType); 360 size += vn_sizeof_VkFormat(&val->format); 361 size += vn_sizeof_VkExtent3D(&val->extent); 362 size += vn_sizeof_uint32_t(&val->mipLevels); 363 size += vn_sizeof_uint32_t(&val->arrayLayers); 364 size += vn_sizeof_VkSampleCountFlagBits(&val->samples); 365 size += vn_sizeof_VkImageTiling(&val->tiling); 366 size += vn_sizeof_VkFlags(&val->usage); 367 size += vn_sizeof_VkSharingMode(&val->sharingMode); 368 size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount); 369 if (val->pQueueFamilyIndices) { 370 size += vn_sizeof_array_size(val->queueFamilyIndexCount); 371 size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount); 372 } else { 373 size += vn_sizeof_array_size(0); 374 } 375 size += vn_sizeof_VkImageLayout(&val->initialLayout); 376 return size; 377 } 378 379 static inline size_t 380 vn_sizeof_VkImageCreateInfo(const VkImageCreateInfo *val) 381 { 382 size_t size = 0; 383 384 size += vn_sizeof_VkStructureType(&val->sType); 385 size += vn_sizeof_VkImageCreateInfo_pnext(val->pNext); 386 size += vn_sizeof_VkImageCreateInfo_self(val); 387 388 return size; 389 } 390 391 static inline void 392 vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) 393 { 394 const VkBaseInStructure *pnext = val; 395 396 while (pnext) { 397 switch ((int32_t)pnext->sType) { 398 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: 399 vn_encode_simple_pointer(enc, pnext); 400 vn_encode_VkStructureType(enc, &pnext->sType); 401 vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); 402 vn_encode_VkExternalMemoryImageCreateInfo_self(enc, (const VkExternalMemoryImageCreateInfo *)pnext); 403 return; 404 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: 405 vn_encode_simple_pointer(enc, pnext); 406 vn_encode_VkStructureType(enc, &pnext->sType); 407 vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); 408 vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext); 409 return; 410 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: 411 vn_encode_simple_pointer(enc, pnext); 412 vn_encode_VkStructureType(enc, &pnext->sType); 413 vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); 414 vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierListCreateInfoEXT *)pnext); 415 return; 416 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: 417 vn_encode_simple_pointer(enc, pnext); 418 vn_encode_VkStructureType(enc, &pnext->sType); 419 vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); 420 vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext); 421 return; 422 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: 423 vn_encode_simple_pointer(enc, pnext); 424 vn_encode_VkStructureType(enc, &pnext->sType); 425 vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); 426 vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext); 427 return; 428 default: 429 /* ignore unknown/unsupported struct */ 430 break; 431 } 432 pnext = pnext->pNext; 433 } 434 435 vn_encode_simple_pointer(enc, NULL); 436 } 437 438 static inline void 439 vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageCreateInfo *val) 440 { 441 /* skip val->{sType,pNext} */ 442 vn_encode_VkFlags(enc, &val->flags); 443 vn_encode_VkImageType(enc, &val->imageType); 444 vn_encode_VkFormat(enc, &val->format); 445 vn_encode_VkExtent3D(enc, &val->extent); 446 vn_encode_uint32_t(enc, &val->mipLevels); 447 vn_encode_uint32_t(enc, &val->arrayLayers); 448 vn_encode_VkSampleCountFlagBits(enc, &val->samples); 449 vn_encode_VkImageTiling(enc, &val->tiling); 450 vn_encode_VkFlags(enc, &val->usage); 451 vn_encode_VkSharingMode(enc, &val->sharingMode); 452 vn_encode_uint32_t(enc, &val->queueFamilyIndexCount); 453 if (val->pQueueFamilyIndices) { 454 vn_encode_array_size(enc, val->queueFamilyIndexCount); 455 vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount); 456 } else { 457 vn_encode_array_size(enc, 0); 458 } 459 vn_encode_VkImageLayout(enc, &val->initialLayout); 460 } 461 462 static inline void 463 vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *val) 464 { 465 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO); 466 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO }); 467 vn_encode_VkImageCreateInfo_pnext(enc, val->pNext); 468 vn_encode_VkImageCreateInfo_self(enc, val); 469 } 470 471 /* struct VkBindImageMemoryDeviceGroupInfo chain */ 472 473 static inline size_t 474 vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void *val) 475 { 476 /* no known/supported struct */ 477 return vn_sizeof_simple_pointer(NULL); 478 } 479 480 static inline size_t 481 vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(const VkBindImageMemoryDeviceGroupInfo *val) 482 { 483 size_t size = 0; 484 /* skip val->{sType,pNext} */ 485 size += vn_sizeof_uint32_t(&val->deviceIndexCount); 486 if (val->pDeviceIndices) { 487 size += vn_sizeof_array_size(val->deviceIndexCount); 488 size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount); 489 } else { 490 size += vn_sizeof_array_size(0); 491 } 492 size += vn_sizeof_uint32_t(&val->splitInstanceBindRegionCount); 493 if (val->pSplitInstanceBindRegions) { 494 size += vn_sizeof_array_size(val->splitInstanceBindRegionCount); 495 for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++) 496 size += vn_sizeof_VkRect2D(&val->pSplitInstanceBindRegions[i]); 497 } else { 498 size += vn_sizeof_array_size(0); 499 } 500 return size; 501 } 502 503 static inline size_t 504 vn_sizeof_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo *val) 505 { 506 size_t size = 0; 507 508 size += vn_sizeof_VkStructureType(&val->sType); 509 size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(val->pNext); 510 size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(val); 511 512 return size; 513 } 514 515 static inline void 516 vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val) 517 { 518 /* no known/supported struct */ 519 vn_encode_simple_pointer(enc, NULL); 520 } 521 522 static inline void 523 vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val) 524 { 525 /* skip val->{sType,pNext} */ 526 vn_encode_uint32_t(enc, &val->deviceIndexCount); 527 if (val->pDeviceIndices) { 528 vn_encode_array_size(enc, val->deviceIndexCount); 529 vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount); 530 } else { 531 vn_encode_array_size(enc, 0); 532 } 533 vn_encode_uint32_t(enc, &val->splitInstanceBindRegionCount); 534 if (val->pSplitInstanceBindRegions) { 535 vn_encode_array_size(enc, val->splitInstanceBindRegionCount); 536 for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++) 537 vn_encode_VkRect2D(enc, &val->pSplitInstanceBindRegions[i]); 538 } else { 539 vn_encode_array_size(enc, 0); 540 } 541 } 542 543 static inline void 544 vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val) 545 { 546 assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO); 547 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO }); 548 vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(enc, val->pNext); 549 vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, val); 550 } 551 552 static inline void 553 vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val) 554 { 555 /* no known/supported struct */ 556 if (vn_decode_simple_pointer(dec)) 557 assert(false); 558 } 559 560 static inline void 561 vn_decode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val) 562 { 563 /* skip val->{sType,pNext} */ 564 vn_decode_uint32_t(dec, &val->deviceIndexCount); 565 if (vn_peek_array_size(dec)) { 566 const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount); 567 vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size); 568 } else { 569 vn_decode_array_size_unchecked(dec); 570 val->pDeviceIndices = NULL; 571 } 572 vn_decode_uint32_t(dec, &val->splitInstanceBindRegionCount); 573 if (vn_peek_array_size(dec)) { 574 const uint32_t iter_count = vn_decode_array_size(dec, val->splitInstanceBindRegionCount); 575 for (uint32_t i = 0; i < iter_count; i++) 576 vn_decode_VkRect2D(dec, &((VkRect2D *)val->pSplitInstanceBindRegions)[i]); 577 } else { 578 vn_decode_array_size_unchecked(dec); 579 val->pSplitInstanceBindRegions = NULL; 580 } 581 } 582 583 static inline void 584 vn_decode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val) 585 { 586 VkStructureType stype; 587 vn_decode_VkStructureType(dec, &stype); 588 assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO); 589 590 assert(val->sType == stype); 591 vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(dec, val->pNext); 592 vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, val); 593 } 594 595 /* struct VkBindImagePlaneMemoryInfo chain */ 596 597 static inline size_t 598 vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void *val) 599 { 600 /* no known/supported struct */ 601 return vn_sizeof_simple_pointer(NULL); 602 } 603 604 static inline size_t 605 vn_sizeof_VkBindImagePlaneMemoryInfo_self(const VkBindImagePlaneMemoryInfo *val) 606 { 607 size_t size = 0; 608 /* skip val->{sType,pNext} */ 609 size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect); 610 return size; 611 } 612 613 static inline size_t 614 vn_sizeof_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo *val) 615 { 616 size_t size = 0; 617 618 size += vn_sizeof_VkStructureType(&val->sType); 619 size += vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(val->pNext); 620 size += vn_sizeof_VkBindImagePlaneMemoryInfo_self(val); 621 622 return size; 623 } 624 625 static inline void 626 vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val) 627 { 628 /* no known/supported struct */ 629 vn_encode_simple_pointer(enc, NULL); 630 } 631 632 static inline void 633 vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val) 634 { 635 /* skip val->{sType,pNext} */ 636 vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect); 637 } 638 639 static inline void 640 vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val) 641 { 642 assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO); 643 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO }); 644 vn_encode_VkBindImagePlaneMemoryInfo_pnext(enc, val->pNext); 645 vn_encode_VkBindImagePlaneMemoryInfo_self(enc, val); 646 } 647 648 static inline void 649 vn_decode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val) 650 { 651 /* no known/supported struct */ 652 if (vn_decode_simple_pointer(dec)) 653 assert(false); 654 } 655 656 static inline void 657 vn_decode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val) 658 { 659 /* skip val->{sType,pNext} */ 660 vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect); 661 } 662 663 static inline void 664 vn_decode_VkBindImagePlaneMemoryInfo(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val) 665 { 666 VkStructureType stype; 667 vn_decode_VkStructureType(dec, &stype); 668 assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO); 669 670 assert(val->sType == stype); 671 vn_decode_VkBindImagePlaneMemoryInfo_pnext(dec, val->pNext); 672 vn_decode_VkBindImagePlaneMemoryInfo_self(dec, val); 673 } 674 675 /* struct VkBindImageMemoryInfo chain */ 676 677 static inline size_t 678 vn_sizeof_VkBindImageMemoryInfo_pnext(const void *val) 679 { 680 const VkBaseInStructure *pnext = val; 681 size_t size = 0; 682 683 while (pnext) { 684 switch ((int32_t)pnext->sType) { 685 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: 686 size += vn_sizeof_simple_pointer(pnext); 687 size += vn_sizeof_VkStructureType(&pnext->sType); 688 size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext); 689 size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self((const VkBindImageMemoryDeviceGroupInfo *)pnext); 690 return size; 691 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: 692 size += vn_sizeof_simple_pointer(pnext); 693 size += vn_sizeof_VkStructureType(&pnext->sType); 694 size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext); 695 size += vn_sizeof_VkBindImagePlaneMemoryInfo_self((const VkBindImagePlaneMemoryInfo *)pnext); 696 return size; 697 default: 698 /* ignore unknown/unsupported struct */ 699 break; 700 } 701 pnext = pnext->pNext; 702 } 703 704 return vn_sizeof_simple_pointer(NULL); 705 } 706 707 static inline size_t 708 vn_sizeof_VkBindImageMemoryInfo_self(const VkBindImageMemoryInfo *val) 709 { 710 size_t size = 0; 711 /* skip val->{sType,pNext} */ 712 size += vn_sizeof_VkImage(&val->image); 713 size += vn_sizeof_VkDeviceMemory(&val->memory); 714 size += vn_sizeof_VkDeviceSize(&val->memoryOffset); 715 return size; 716 } 717 718 static inline size_t 719 vn_sizeof_VkBindImageMemoryInfo(const VkBindImageMemoryInfo *val) 720 { 721 size_t size = 0; 722 723 size += vn_sizeof_VkStructureType(&val->sType); 724 size += vn_sizeof_VkBindImageMemoryInfo_pnext(val->pNext); 725 size += vn_sizeof_VkBindImageMemoryInfo_self(val); 726 727 return size; 728 } 729 730 static inline void 731 vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val) 732 { 733 const VkBaseInStructure *pnext = val; 734 735 while (pnext) { 736 switch ((int32_t)pnext->sType) { 737 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: 738 vn_encode_simple_pointer(enc, pnext); 739 vn_encode_VkStructureType(enc, &pnext->sType); 740 vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext); 741 vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, (const VkBindImageMemoryDeviceGroupInfo *)pnext); 742 return; 743 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: 744 vn_encode_simple_pointer(enc, pnext); 745 vn_encode_VkStructureType(enc, &pnext->sType); 746 vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext); 747 vn_encode_VkBindImagePlaneMemoryInfo_self(enc, (const VkBindImagePlaneMemoryInfo *)pnext); 748 return; 749 default: 750 /* ignore unknown/unsupported struct */ 751 break; 752 } 753 pnext = pnext->pNext; 754 } 755 756 vn_encode_simple_pointer(enc, NULL); 757 } 758 759 static inline void 760 vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val) 761 { 762 /* skip val->{sType,pNext} */ 763 vn_encode_VkImage(enc, &val->image); 764 vn_encode_VkDeviceMemory(enc, &val->memory); 765 vn_encode_VkDeviceSize(enc, &val->memoryOffset); 766 } 767 768 static inline void 769 vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val) 770 { 771 assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO); 772 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO }); 773 vn_encode_VkBindImageMemoryInfo_pnext(enc, val->pNext); 774 vn_encode_VkBindImageMemoryInfo_self(enc, val); 775 } 776 777 static inline void 778 vn_decode_VkBindImageMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val) 779 { 780 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; 781 VkStructureType stype; 782 783 if (!vn_decode_simple_pointer(dec)) 784 return; 785 786 vn_decode_VkStructureType(dec, &stype); 787 while (true) { 788 assert(pnext); 789 if (pnext->sType == stype) 790 break; 791 } 792 793 switch ((int32_t)pnext->sType) { 794 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: 795 vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext); 796 vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, (VkBindImageMemoryDeviceGroupInfo *)pnext); 797 break; 798 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: 799 vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext); 800 vn_decode_VkBindImagePlaneMemoryInfo_self(dec, (VkBindImagePlaneMemoryInfo *)pnext); 801 break; 802 default: 803 assert(false); 804 break; 805 } 806 } 807 808 static inline void 809 vn_decode_VkBindImageMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val) 810 { 811 /* skip val->{sType,pNext} */ 812 vn_decode_VkImage(dec, &val->image); 813 vn_decode_VkDeviceMemory(dec, &val->memory); 814 vn_decode_VkDeviceSize(dec, &val->memoryOffset); 815 } 816 817 static inline void 818 vn_decode_VkBindImageMemoryInfo(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val) 819 { 820 VkStructureType stype; 821 vn_decode_VkStructureType(dec, &stype); 822 assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO); 823 824 assert(val->sType == stype); 825 vn_decode_VkBindImageMemoryInfo_pnext(dec, val->pNext); 826 vn_decode_VkBindImageMemoryInfo_self(dec, val); 827 } 828 829 /* struct VkImagePlaneMemoryRequirementsInfo chain */ 830 831 static inline size_t 832 vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void *val) 833 { 834 /* no known/supported struct */ 835 return vn_sizeof_simple_pointer(NULL); 836 } 837 838 static inline size_t 839 vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(const VkImagePlaneMemoryRequirementsInfo *val) 840 { 841 size_t size = 0; 842 /* skip val->{sType,pNext} */ 843 size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect); 844 return size; 845 } 846 847 static inline size_t 848 vn_sizeof_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo *val) 849 { 850 size_t size = 0; 851 852 size += vn_sizeof_VkStructureType(&val->sType); 853 size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(val->pNext); 854 size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(val); 855 856 return size; 857 } 858 859 static inline void 860 vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(struct vn_cs_encoder *enc, const void *val) 861 { 862 /* no known/supported struct */ 863 vn_encode_simple_pointer(enc, NULL); 864 } 865 866 static inline void 867 vn_encode_VkImagePlaneMemoryRequirementsInfo_self(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val) 868 { 869 /* skip val->{sType,pNext} */ 870 vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect); 871 } 872 873 static inline void 874 vn_encode_VkImagePlaneMemoryRequirementsInfo(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val) 875 { 876 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO); 877 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO }); 878 vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(enc, val->pNext); 879 vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, val); 880 } 881 882 /* struct VkImageMemoryRequirementsInfo2 chain */ 883 884 static inline size_t 885 vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(const void *val) 886 { 887 const VkBaseInStructure *pnext = val; 888 size_t size = 0; 889 890 while (pnext) { 891 switch ((int32_t)pnext->sType) { 892 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: 893 size += vn_sizeof_simple_pointer(pnext); 894 size += vn_sizeof_VkStructureType(&pnext->sType); 895 size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(pnext->pNext); 896 size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self((const VkImagePlaneMemoryRequirementsInfo *)pnext); 897 return size; 898 default: 899 /* ignore unknown/unsupported struct */ 900 break; 901 } 902 pnext = pnext->pNext; 903 } 904 905 return vn_sizeof_simple_pointer(NULL); 906 } 907 908 static inline size_t 909 vn_sizeof_VkImageMemoryRequirementsInfo2_self(const VkImageMemoryRequirementsInfo2 *val) 910 { 911 size_t size = 0; 912 /* skip val->{sType,pNext} */ 913 size += vn_sizeof_VkImage(&val->image); 914 return size; 915 } 916 917 static inline size_t 918 vn_sizeof_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 *val) 919 { 920 size_t size = 0; 921 922 size += vn_sizeof_VkStructureType(&val->sType); 923 size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(val->pNext); 924 size += vn_sizeof_VkImageMemoryRequirementsInfo2_self(val); 925 926 return size; 927 } 928 929 static inline void 930 vn_encode_VkImageMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val) 931 { 932 const VkBaseInStructure *pnext = val; 933 934 while (pnext) { 935 switch ((int32_t)pnext->sType) { 936 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: 937 vn_encode_simple_pointer(enc, pnext); 938 vn_encode_VkStructureType(enc, &pnext->sType); 939 vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, pnext->pNext); 940 vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, (const VkImagePlaneMemoryRequirementsInfo *)pnext); 941 return; 942 default: 943 /* ignore unknown/unsupported struct */ 944 break; 945 } 946 pnext = pnext->pNext; 947 } 948 949 vn_encode_simple_pointer(enc, NULL); 950 } 951 952 static inline void 953 vn_encode_VkImageMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val) 954 { 955 /* skip val->{sType,pNext} */ 956 vn_encode_VkImage(enc, &val->image); 957 } 958 959 static inline void 960 vn_encode_VkImageMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val) 961 { 962 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2); 963 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 }); 964 vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, val->pNext); 965 vn_encode_VkImageMemoryRequirementsInfo2_self(enc, val); 966 } 967 968 /* struct VkImageSparseMemoryRequirementsInfo2 chain */ 969 970 static inline size_t 971 vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void *val) 972 { 973 /* no known/supported struct */ 974 return vn_sizeof_simple_pointer(NULL); 975 } 976 977 static inline size_t 978 vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(const VkImageSparseMemoryRequirementsInfo2 *val) 979 { 980 size_t size = 0; 981 /* skip val->{sType,pNext} */ 982 size += vn_sizeof_VkImage(&val->image); 983 return size; 984 } 985 986 static inline size_t 987 vn_sizeof_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2 *val) 988 { 989 size_t size = 0; 990 991 size += vn_sizeof_VkStructureType(&val->sType); 992 size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(val->pNext); 993 size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(val); 994 995 return size; 996 } 997 998 static inline void 999 vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val) 1000 { 1001 /* no known/supported struct */ 1002 vn_encode_simple_pointer(enc, NULL); 1003 } 1004 1005 static inline void 1006 vn_encode_VkImageSparseMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val) 1007 { 1008 /* skip val->{sType,pNext} */ 1009 vn_encode_VkImage(enc, &val->image); 1010 } 1011 1012 static inline void 1013 vn_encode_VkImageSparseMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val) 1014 { 1015 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2); 1016 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 }); 1017 vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(enc, val->pNext); 1018 vn_encode_VkImageSparseMemoryRequirementsInfo2_self(enc, val); 1019 } 1020 1021 /* struct VkSparseImageMemoryRequirements2 chain */ 1022 1023 static inline size_t 1024 vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void *val) 1025 { 1026 /* no known/supported struct */ 1027 return vn_sizeof_simple_pointer(NULL); 1028 } 1029 1030 static inline size_t 1031 vn_sizeof_VkSparseImageMemoryRequirements2_self(const VkSparseImageMemoryRequirements2 *val) 1032 { 1033 size_t size = 0; 1034 /* skip val->{sType,pNext} */ 1035 size += vn_sizeof_VkSparseImageMemoryRequirements(&val->memoryRequirements); 1036 return size; 1037 } 1038 1039 static inline size_t 1040 vn_sizeof_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2 *val) 1041 { 1042 size_t size = 0; 1043 1044 size += vn_sizeof_VkStructureType(&val->sType); 1045 size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext(val->pNext); 1046 size += vn_sizeof_VkSparseImageMemoryRequirements2_self(val); 1047 1048 return size; 1049 } 1050 1051 static inline void 1052 vn_decode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val) 1053 { 1054 /* no known/supported struct */ 1055 if (vn_decode_simple_pointer(dec)) 1056 assert(false); 1057 } 1058 1059 static inline void 1060 vn_decode_VkSparseImageMemoryRequirements2_self(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val) 1061 { 1062 /* skip val->{sType,pNext} */ 1063 vn_decode_VkSparseImageMemoryRequirements(dec, &val->memoryRequirements); 1064 } 1065 1066 static inline void 1067 vn_decode_VkSparseImageMemoryRequirements2(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val) 1068 { 1069 VkStructureType stype; 1070 vn_decode_VkStructureType(dec, &stype); 1071 assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2); 1072 1073 assert(val->sType == stype); 1074 vn_decode_VkSparseImageMemoryRequirements2_pnext(dec, val->pNext); 1075 vn_decode_VkSparseImageMemoryRequirements2_self(dec, val); 1076 } 1077 1078 static inline size_t 1079 vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void *val) 1080 { 1081 /* no known/supported struct */ 1082 return vn_sizeof_simple_pointer(NULL); 1083 } 1084 1085 static inline size_t 1086 vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(const VkSparseImageMemoryRequirements2 *val) 1087 { 1088 size_t size = 0; 1089 /* skip val->{sType,pNext} */ 1090 size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&val->memoryRequirements); 1091 return size; 1092 } 1093 1094 static inline size_t 1095 vn_sizeof_VkSparseImageMemoryRequirements2_partial(const VkSparseImageMemoryRequirements2 *val) 1096 { 1097 size_t size = 0; 1098 1099 size += vn_sizeof_VkStructureType(&val->sType); 1100 size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(val->pNext); 1101 size += vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(val); 1102 1103 return size; 1104 } 1105 1106 static inline void 1107 vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val) 1108 { 1109 /* no known/supported struct */ 1110 vn_encode_simple_pointer(enc, NULL); 1111 } 1112 1113 static inline void 1114 vn_encode_VkSparseImageMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val) 1115 { 1116 /* skip val->{sType,pNext} */ 1117 vn_encode_VkSparseImageMemoryRequirements_partial(enc, &val->memoryRequirements); 1118 } 1119 1120 static inline void 1121 vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val) 1122 { 1123 assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2); 1124 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 }); 1125 vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(enc, val->pNext); 1126 vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val); 1127 } 1128 1129 /* struct VkImageDrmFormatModifierPropertiesEXT chain */ 1130 1131 static inline size_t 1132 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void *val) 1133 { 1134 /* no known/supported struct */ 1135 return vn_sizeof_simple_pointer(NULL); 1136 } 1137 1138 static inline size_t 1139 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(const VkImageDrmFormatModifierPropertiesEXT *val) 1140 { 1141 size_t size = 0; 1142 /* skip val->{sType,pNext} */ 1143 size += vn_sizeof_uint64_t(&val->drmFormatModifier); 1144 return size; 1145 } 1146 1147 static inline size_t 1148 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT *val) 1149 { 1150 size_t size = 0; 1151 1152 size += vn_sizeof_VkStructureType(&val->sType); 1153 size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(val->pNext); 1154 size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(val); 1155 1156 return size; 1157 } 1158 1159 static inline void 1160 vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val) 1161 { 1162 /* no known/supported struct */ 1163 if (vn_decode_simple_pointer(dec)) 1164 assert(false); 1165 } 1166 1167 static inline void 1168 vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val) 1169 { 1170 /* skip val->{sType,pNext} */ 1171 vn_decode_uint64_t(dec, &val->drmFormatModifier); 1172 } 1173 1174 static inline void 1175 vn_decode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val) 1176 { 1177 VkStructureType stype; 1178 vn_decode_VkStructureType(dec, &stype); 1179 assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT); 1180 1181 assert(val->sType == stype); 1182 vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(dec, val->pNext); 1183 vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(dec, val); 1184 } 1185 1186 static inline size_t 1187 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void *val) 1188 { 1189 /* no known/supported struct */ 1190 return vn_sizeof_simple_pointer(NULL); 1191 } 1192 1193 static inline size_t 1194 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(const VkImageDrmFormatModifierPropertiesEXT *val) 1195 { 1196 size_t size = 0; 1197 /* skip val->{sType,pNext} */ 1198 /* skip val->drmFormatModifier */ 1199 return size; 1200 } 1201 1202 static inline size_t 1203 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(const VkImageDrmFormatModifierPropertiesEXT *val) 1204 { 1205 size_t size = 0; 1206 1207 size += vn_sizeof_VkStructureType(&val->sType); 1208 size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(val->pNext); 1209 size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(val); 1210 1211 return size; 1212 } 1213 1214 static inline void 1215 vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) 1216 { 1217 /* no known/supported struct */ 1218 vn_encode_simple_pointer(enc, NULL); 1219 } 1220 1221 static inline void 1222 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val) 1223 { 1224 /* skip val->{sType,pNext} */ 1225 /* skip val->drmFormatModifier */ 1226 } 1227 1228 static inline void 1229 vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val) 1230 { 1231 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT); 1232 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT }); 1233 vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(enc, val->pNext); 1234 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(enc, val); 1235 } 1236 1237 static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 1238 { 1239 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT; 1240 const VkFlags cmd_flags = 0; 1241 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1242 1243 cmd_size += vn_sizeof_VkDevice(&device); 1244 cmd_size += vn_sizeof_VkImage(&image); 1245 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); 1246 if (pMemoryRequirements) 1247 cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements); 1248 1249 return cmd_size; 1250 } 1251 1252 static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 1253 { 1254 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT; 1255 1256 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1257 vn_encode_VkFlags(enc, &cmd_flags); 1258 1259 vn_encode_VkDevice(enc, &device); 1260 vn_encode_VkImage(enc, &image); 1261 if (vn_encode_simple_pointer(enc, pMemoryRequirements)) 1262 vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements); 1263 } 1264 1265 static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 1266 { 1267 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT; 1268 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1269 1270 /* skip device */ 1271 /* skip image */ 1272 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); 1273 if (pMemoryRequirements) 1274 cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements); 1275 1276 return cmd_size; 1277 } 1278 1279 static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 1280 { 1281 VkCommandTypeEXT command_type; 1282 vn_decode_VkCommandTypeEXT(dec, &command_type); 1283 assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT); 1284 1285 /* skip device */ 1286 /* skip image */ 1287 if (vn_decode_simple_pointer(dec)) { 1288 vn_decode_VkMemoryRequirements(dec, pMemoryRequirements); 1289 } else { 1290 pMemoryRequirements = NULL; 1291 } 1292 } 1293 1294 static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 1295 { 1296 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT; 1297 const VkFlags cmd_flags = 0; 1298 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1299 1300 cmd_size += vn_sizeof_VkDevice(&device); 1301 cmd_size += vn_sizeof_VkImage(&image); 1302 cmd_size += vn_sizeof_VkDeviceMemory(&memory); 1303 cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset); 1304 1305 return cmd_size; 1306 } 1307 1308 static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 1309 { 1310 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT; 1311 1312 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1313 vn_encode_VkFlags(enc, &cmd_flags); 1314 1315 vn_encode_VkDevice(enc, &device); 1316 vn_encode_VkImage(enc, &image); 1317 vn_encode_VkDeviceMemory(enc, &memory); 1318 vn_encode_VkDeviceSize(enc, &memoryOffset); 1319 } 1320 1321 static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 1322 { 1323 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT; 1324 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1325 1326 VkResult ret; 1327 cmd_size += vn_sizeof_VkResult(&ret); 1328 /* skip device */ 1329 /* skip image */ 1330 /* skip memory */ 1331 /* skip memoryOffset */ 1332 1333 return cmd_size; 1334 } 1335 1336 static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 1337 { 1338 VkCommandTypeEXT command_type; 1339 vn_decode_VkCommandTypeEXT(dec, &command_type); 1340 assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT); 1341 1342 VkResult ret; 1343 vn_decode_VkResult(dec, &ret); 1344 /* skip device */ 1345 /* skip image */ 1346 /* skip memory */ 1347 /* skip memoryOffset */ 1348 1349 return ret; 1350 } 1351 1352 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 1353 { 1354 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT; 1355 const VkFlags cmd_flags = 0; 1356 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1357 1358 cmd_size += vn_sizeof_VkDevice(&device); 1359 cmd_size += vn_sizeof_VkImage(&image); 1360 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); 1361 if (pSparseMemoryRequirementCount) 1362 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); 1363 if (pSparseMemoryRequirements) { 1364 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1365 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) 1366 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]); 1367 } else { 1368 cmd_size += vn_sizeof_array_size(0); 1369 } 1370 1371 return cmd_size; 1372 } 1373 1374 static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 1375 { 1376 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT; 1377 1378 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1379 vn_encode_VkFlags(enc, &cmd_flags); 1380 1381 vn_encode_VkDevice(enc, &device); 1382 vn_encode_VkImage(enc, &image); 1383 if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount)) 1384 vn_encode_uint32_t(enc, pSparseMemoryRequirementCount); 1385 if (pSparseMemoryRequirements) { 1386 vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1387 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) 1388 vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]); 1389 } else { 1390 vn_encode_array_size(enc, 0); 1391 } 1392 } 1393 1394 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 1395 { 1396 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT; 1397 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1398 1399 /* skip device */ 1400 /* skip image */ 1401 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); 1402 if (pSparseMemoryRequirementCount) 1403 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); 1404 if (pSparseMemoryRequirements) { 1405 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1406 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) 1407 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]); 1408 } else { 1409 cmd_size += vn_sizeof_array_size(0); 1410 } 1411 1412 return cmd_size; 1413 } 1414 1415 static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 1416 { 1417 VkCommandTypeEXT command_type; 1418 vn_decode_VkCommandTypeEXT(dec, &command_type); 1419 assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT); 1420 1421 /* skip device */ 1422 /* skip image */ 1423 if (vn_decode_simple_pointer(dec)) { 1424 vn_decode_uint32_t(dec, pSparseMemoryRequirementCount); 1425 } else { 1426 pSparseMemoryRequirementCount = NULL; 1427 } 1428 if (vn_peek_array_size(dec)) { 1429 const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1430 for (uint32_t i = 0; i < iter_count; i++) 1431 vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]); 1432 } else { 1433 vn_decode_array_size_unchecked(dec); 1434 pSparseMemoryRequirements = NULL; 1435 } 1436 } 1437 1438 static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 1439 { 1440 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT; 1441 const VkFlags cmd_flags = 0; 1442 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1443 1444 cmd_size += vn_sizeof_VkDevice(&device); 1445 cmd_size += vn_sizeof_simple_pointer(pCreateInfo); 1446 if (pCreateInfo) 1447 cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo); 1448 cmd_size += vn_sizeof_simple_pointer(pAllocator); 1449 if (pAllocator) 1450 assert(false); 1451 cmd_size += vn_sizeof_simple_pointer(pImage); 1452 if (pImage) 1453 cmd_size += vn_sizeof_VkImage(pImage); 1454 1455 return cmd_size; 1456 } 1457 1458 static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 1459 { 1460 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT; 1461 1462 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1463 vn_encode_VkFlags(enc, &cmd_flags); 1464 1465 vn_encode_VkDevice(enc, &device); 1466 if (vn_encode_simple_pointer(enc, pCreateInfo)) 1467 vn_encode_VkImageCreateInfo(enc, pCreateInfo); 1468 if (vn_encode_simple_pointer(enc, pAllocator)) 1469 assert(false); 1470 if (vn_encode_simple_pointer(enc, pImage)) 1471 vn_encode_VkImage(enc, pImage); 1472 } 1473 1474 static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 1475 { 1476 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT; 1477 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1478 1479 VkResult ret; 1480 cmd_size += vn_sizeof_VkResult(&ret); 1481 /* skip device */ 1482 /* skip pCreateInfo */ 1483 /* skip pAllocator */ 1484 cmd_size += vn_sizeof_simple_pointer(pImage); 1485 if (pImage) 1486 cmd_size += vn_sizeof_VkImage(pImage); 1487 1488 return cmd_size; 1489 } 1490 1491 static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 1492 { 1493 VkCommandTypeEXT command_type; 1494 vn_decode_VkCommandTypeEXT(dec, &command_type); 1495 assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT); 1496 1497 VkResult ret; 1498 vn_decode_VkResult(dec, &ret); 1499 /* skip device */ 1500 /* skip pCreateInfo */ 1501 /* skip pAllocator */ 1502 if (vn_decode_simple_pointer(dec)) { 1503 vn_decode_VkImage(dec, pImage); 1504 } else { 1505 pImage = NULL; 1506 } 1507 1508 return ret; 1509 } 1510 1511 static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 1512 { 1513 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT; 1514 const VkFlags cmd_flags = 0; 1515 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1516 1517 cmd_size += vn_sizeof_VkDevice(&device); 1518 cmd_size += vn_sizeof_VkImage(&image); 1519 cmd_size += vn_sizeof_simple_pointer(pAllocator); 1520 if (pAllocator) 1521 assert(false); 1522 1523 return cmd_size; 1524 } 1525 1526 static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 1527 { 1528 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT; 1529 1530 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1531 vn_encode_VkFlags(enc, &cmd_flags); 1532 1533 vn_encode_VkDevice(enc, &device); 1534 vn_encode_VkImage(enc, &image); 1535 if (vn_encode_simple_pointer(enc, pAllocator)) 1536 assert(false); 1537 } 1538 1539 static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 1540 { 1541 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT; 1542 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1543 1544 /* skip device */ 1545 /* skip image */ 1546 /* skip pAllocator */ 1547 1548 return cmd_size; 1549 } 1550 1551 static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 1552 { 1553 VkCommandTypeEXT command_type; 1554 vn_decode_VkCommandTypeEXT(dec, &command_type); 1555 assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT); 1556 1557 /* skip device */ 1558 /* skip image */ 1559 /* skip pAllocator */ 1560 } 1561 1562 static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 1563 { 1564 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT; 1565 const VkFlags cmd_flags = 0; 1566 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1567 1568 cmd_size += vn_sizeof_VkDevice(&device); 1569 cmd_size += vn_sizeof_VkImage(&image); 1570 cmd_size += vn_sizeof_simple_pointer(pSubresource); 1571 if (pSubresource) 1572 cmd_size += vn_sizeof_VkImageSubresource(pSubresource); 1573 cmd_size += vn_sizeof_simple_pointer(pLayout); 1574 if (pLayout) 1575 cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout); 1576 1577 return cmd_size; 1578 } 1579 1580 static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 1581 { 1582 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT; 1583 1584 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1585 vn_encode_VkFlags(enc, &cmd_flags); 1586 1587 vn_encode_VkDevice(enc, &device); 1588 vn_encode_VkImage(enc, &image); 1589 if (vn_encode_simple_pointer(enc, pSubresource)) 1590 vn_encode_VkImageSubresource(enc, pSubresource); 1591 if (vn_encode_simple_pointer(enc, pLayout)) 1592 vn_encode_VkSubresourceLayout_partial(enc, pLayout); 1593 } 1594 1595 static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 1596 { 1597 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT; 1598 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1599 1600 /* skip device */ 1601 /* skip image */ 1602 /* skip pSubresource */ 1603 cmd_size += vn_sizeof_simple_pointer(pLayout); 1604 if (pLayout) 1605 cmd_size += vn_sizeof_VkSubresourceLayout(pLayout); 1606 1607 return cmd_size; 1608 } 1609 1610 static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 1611 { 1612 VkCommandTypeEXT command_type; 1613 vn_decode_VkCommandTypeEXT(dec, &command_type); 1614 assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT); 1615 1616 /* skip device */ 1617 /* skip image */ 1618 /* skip pSubresource */ 1619 if (vn_decode_simple_pointer(dec)) { 1620 vn_decode_VkSubresourceLayout(dec, pLayout); 1621 } else { 1622 pLayout = NULL; 1623 } 1624 } 1625 1626 static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) 1627 { 1628 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT; 1629 const VkFlags cmd_flags = 0; 1630 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1631 1632 cmd_size += vn_sizeof_VkDevice(&device); 1633 cmd_size += vn_sizeof_uint32_t(&bindInfoCount); 1634 if (pBindInfos) { 1635 cmd_size += vn_sizeof_array_size(bindInfoCount); 1636 for (uint32_t i = 0; i < bindInfoCount; i++) 1637 cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]); 1638 } else { 1639 cmd_size += vn_sizeof_array_size(0); 1640 } 1641 1642 return cmd_size; 1643 } 1644 1645 static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) 1646 { 1647 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT; 1648 1649 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1650 vn_encode_VkFlags(enc, &cmd_flags); 1651 1652 vn_encode_VkDevice(enc, &device); 1653 vn_encode_uint32_t(enc, &bindInfoCount); 1654 if (pBindInfos) { 1655 vn_encode_array_size(enc, bindInfoCount); 1656 for (uint32_t i = 0; i < bindInfoCount; i++) 1657 vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]); 1658 } else { 1659 vn_encode_array_size(enc, 0); 1660 } 1661 } 1662 1663 static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) 1664 { 1665 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT; 1666 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1667 1668 VkResult ret; 1669 cmd_size += vn_sizeof_VkResult(&ret); 1670 /* skip device */ 1671 /* skip bindInfoCount */ 1672 /* skip pBindInfos */ 1673 1674 return cmd_size; 1675 } 1676 1677 static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) 1678 { 1679 VkCommandTypeEXT command_type; 1680 vn_decode_VkCommandTypeEXT(dec, &command_type); 1681 assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT); 1682 1683 VkResult ret; 1684 vn_decode_VkResult(dec, &ret); 1685 /* skip device */ 1686 /* skip bindInfoCount */ 1687 /* skip pBindInfos */ 1688 1689 return ret; 1690 } 1691 1692 static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) 1693 { 1694 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT; 1695 const VkFlags cmd_flags = 0; 1696 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1697 1698 cmd_size += vn_sizeof_VkDevice(&device); 1699 cmd_size += vn_sizeof_simple_pointer(pInfo); 1700 if (pInfo) 1701 cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo); 1702 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); 1703 if (pMemoryRequirements) 1704 cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements); 1705 1706 return cmd_size; 1707 } 1708 1709 static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) 1710 { 1711 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT; 1712 1713 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1714 vn_encode_VkFlags(enc, &cmd_flags); 1715 1716 vn_encode_VkDevice(enc, &device); 1717 if (vn_encode_simple_pointer(enc, pInfo)) 1718 vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo); 1719 if (vn_encode_simple_pointer(enc, pMemoryRequirements)) 1720 vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements); 1721 } 1722 1723 static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) 1724 { 1725 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT; 1726 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1727 1728 /* skip device */ 1729 /* skip pInfo */ 1730 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); 1731 if (pMemoryRequirements) 1732 cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements); 1733 1734 return cmd_size; 1735 } 1736 1737 static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) 1738 { 1739 VkCommandTypeEXT command_type; 1740 vn_decode_VkCommandTypeEXT(dec, &command_type); 1741 assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT); 1742 1743 /* skip device */ 1744 /* skip pInfo */ 1745 if (vn_decode_simple_pointer(dec)) { 1746 vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements); 1747 } else { 1748 pMemoryRequirements = NULL; 1749 } 1750 } 1751 1752 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 1753 { 1754 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT; 1755 const VkFlags cmd_flags = 0; 1756 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1757 1758 cmd_size += vn_sizeof_VkDevice(&device); 1759 cmd_size += vn_sizeof_simple_pointer(pInfo); 1760 if (pInfo) 1761 cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo); 1762 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); 1763 if (pSparseMemoryRequirementCount) 1764 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); 1765 if (pSparseMemoryRequirements) { 1766 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1767 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) 1768 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]); 1769 } else { 1770 cmd_size += vn_sizeof_array_size(0); 1771 } 1772 1773 return cmd_size; 1774 } 1775 1776 static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 1777 { 1778 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT; 1779 1780 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1781 vn_encode_VkFlags(enc, &cmd_flags); 1782 1783 vn_encode_VkDevice(enc, &device); 1784 if (vn_encode_simple_pointer(enc, pInfo)) 1785 vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo); 1786 if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount)) 1787 vn_encode_uint32_t(enc, pSparseMemoryRequirementCount); 1788 if (pSparseMemoryRequirements) { 1789 vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1790 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) 1791 vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]); 1792 } else { 1793 vn_encode_array_size(enc, 0); 1794 } 1795 } 1796 1797 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 1798 { 1799 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT; 1800 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1801 1802 /* skip device */ 1803 /* skip pInfo */ 1804 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); 1805 if (pSparseMemoryRequirementCount) 1806 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); 1807 if (pSparseMemoryRequirements) { 1808 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1809 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) 1810 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]); 1811 } else { 1812 cmd_size += vn_sizeof_array_size(0); 1813 } 1814 1815 return cmd_size; 1816 } 1817 1818 static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 1819 { 1820 VkCommandTypeEXT command_type; 1821 vn_decode_VkCommandTypeEXT(dec, &command_type); 1822 assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT); 1823 1824 /* skip device */ 1825 /* skip pInfo */ 1826 if (vn_decode_simple_pointer(dec)) { 1827 vn_decode_uint32_t(dec, pSparseMemoryRequirementCount); 1828 } else { 1829 pSparseMemoryRequirementCount = NULL; 1830 } 1831 if (vn_peek_array_size(dec)) { 1832 const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); 1833 for (uint32_t i = 0; i < iter_count; i++) 1834 vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]); 1835 } else { 1836 vn_decode_array_size_unchecked(dec); 1837 pSparseMemoryRequirements = NULL; 1838 } 1839 } 1840 1841 static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) 1842 { 1843 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; 1844 const VkFlags cmd_flags = 0; 1845 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); 1846 1847 cmd_size += vn_sizeof_VkDevice(&device); 1848 cmd_size += vn_sizeof_VkImage(&image); 1849 cmd_size += vn_sizeof_simple_pointer(pProperties); 1850 if (pProperties) 1851 cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties); 1852 1853 return cmd_size; 1854 } 1855 1856 static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) 1857 { 1858 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; 1859 1860 vn_encode_VkCommandTypeEXT(enc, &cmd_type); 1861 vn_encode_VkFlags(enc, &cmd_flags); 1862 1863 vn_encode_VkDevice(enc, &device); 1864 vn_encode_VkImage(enc, &image); 1865 if (vn_encode_simple_pointer(enc, pProperties)) 1866 vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties); 1867 } 1868 1869 static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) 1870 { 1871 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; 1872 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); 1873 1874 VkResult ret; 1875 cmd_size += vn_sizeof_VkResult(&ret); 1876 /* skip device */ 1877 /* skip image */ 1878 cmd_size += vn_sizeof_simple_pointer(pProperties); 1879 if (pProperties) 1880 cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties); 1881 1882 return cmd_size; 1883 } 1884 1885 static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) 1886 { 1887 VkCommandTypeEXT command_type; 1888 vn_decode_VkCommandTypeEXT(dec, &command_type); 1889 assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT); 1890 1891 VkResult ret; 1892 vn_decode_VkResult(dec, &ret); 1893 /* skip device */ 1894 /* skip image */ 1895 if (vn_decode_simple_pointer(dec)) { 1896 vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties); 1897 } else { 1898 pProperties = NULL; 1899 } 1900 1901 return ret; 1902 } 1903 1904 static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit) 1905 { 1906 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 1907 void *cmd_data = local_cmd_data; 1908 size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements); 1909 if (cmd_size > sizeof(local_cmd_data)) { 1910 cmd_data = malloc(cmd_size); 1911 if (!cmd_data) 1912 cmd_size = 0; 1913 } 1914 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0; 1915 1916 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 1917 if (cmd_size) { 1918 vn_encode_vkGetImageMemoryRequirements(enc, cmd_flags, device, image, pMemoryRequirements); 1919 vn_instance_submit_command(vn_instance, submit); 1920 if (cmd_data != local_cmd_data) 1921 free(cmd_data); 1922 } 1923 } 1924 1925 static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit) 1926 { 1927 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 1928 void *cmd_data = local_cmd_data; 1929 size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset); 1930 if (cmd_size > sizeof(local_cmd_data)) { 1931 cmd_data = malloc(cmd_size); 1932 if (!cmd_data) 1933 cmd_size = 0; 1934 } 1935 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0; 1936 1937 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 1938 if (cmd_size) { 1939 vn_encode_vkBindImageMemory(enc, cmd_flags, device, image, memory, memoryOffset); 1940 vn_instance_submit_command(vn_instance, submit); 1941 if (cmd_data != local_cmd_data) 1942 free(cmd_data); 1943 } 1944 } 1945 1946 static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit) 1947 { 1948 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 1949 void *cmd_data = local_cmd_data; 1950 size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 1951 if (cmd_size > sizeof(local_cmd_data)) { 1952 cmd_data = malloc(cmd_size); 1953 if (!cmd_data) 1954 cmd_size = 0; 1955 } 1956 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0; 1957 1958 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 1959 if (cmd_size) { 1960 vn_encode_vkGetImageSparseMemoryRequirements(enc, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 1961 vn_instance_submit_command(vn_instance, submit); 1962 if (cmd_data != local_cmd_data) 1963 free(cmd_data); 1964 } 1965 } 1966 1967 static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit) 1968 { 1969 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 1970 void *cmd_data = local_cmd_data; 1971 size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage); 1972 if (cmd_size > sizeof(local_cmd_data)) { 1973 cmd_data = malloc(cmd_size); 1974 if (!cmd_data) 1975 cmd_size = 0; 1976 } 1977 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0; 1978 1979 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 1980 if (cmd_size) { 1981 vn_encode_vkCreateImage(enc, cmd_flags, device, pCreateInfo, pAllocator, pImage); 1982 vn_instance_submit_command(vn_instance, submit); 1983 if (cmd_data != local_cmd_data) 1984 free(cmd_data); 1985 } 1986 } 1987 1988 static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) 1989 { 1990 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 1991 void *cmd_data = local_cmd_data; 1992 size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator); 1993 if (cmd_size > sizeof(local_cmd_data)) { 1994 cmd_data = malloc(cmd_size); 1995 if (!cmd_data) 1996 cmd_size = 0; 1997 } 1998 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0; 1999 2000 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 2001 if (cmd_size) { 2002 vn_encode_vkDestroyImage(enc, cmd_flags, device, image, pAllocator); 2003 vn_instance_submit_command(vn_instance, submit); 2004 if (cmd_data != local_cmd_data) 2005 free(cmd_data); 2006 } 2007 } 2008 2009 static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit) 2010 { 2011 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 2012 void *cmd_data = local_cmd_data; 2013 size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); 2014 if (cmd_size > sizeof(local_cmd_data)) { 2015 cmd_data = malloc(cmd_size); 2016 if (!cmd_data) 2017 cmd_size = 0; 2018 } 2019 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0; 2020 2021 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 2022 if (cmd_size) { 2023 vn_encode_vkGetImageSubresourceLayout(enc, cmd_flags, device, image, pSubresource, pLayout); 2024 vn_instance_submit_command(vn_instance, submit); 2025 if (cmd_data != local_cmd_data) 2026 free(cmd_data); 2027 } 2028 } 2029 2030 static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit) 2031 { 2032 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 2033 void *cmd_data = local_cmd_data; 2034 size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos); 2035 if (cmd_size > sizeof(local_cmd_data)) { 2036 cmd_data = malloc(cmd_size); 2037 if (!cmd_data) 2038 cmd_size = 0; 2039 } 2040 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0; 2041 2042 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 2043 if (cmd_size) { 2044 vn_encode_vkBindImageMemory2(enc, cmd_flags, device, bindInfoCount, pBindInfos); 2045 vn_instance_submit_command(vn_instance, submit); 2046 if (cmd_data != local_cmd_data) 2047 free(cmd_data); 2048 } 2049 } 2050 2051 static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit) 2052 { 2053 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 2054 void *cmd_data = local_cmd_data; 2055 size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); 2056 if (cmd_size > sizeof(local_cmd_data)) { 2057 cmd_data = malloc(cmd_size); 2058 if (!cmd_data) 2059 cmd_size = 0; 2060 } 2061 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0; 2062 2063 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 2064 if (cmd_size) { 2065 vn_encode_vkGetImageMemoryRequirements2(enc, cmd_flags, device, pInfo, pMemoryRequirements); 2066 vn_instance_submit_command(vn_instance, submit); 2067 if (cmd_data != local_cmd_data) 2068 free(cmd_data); 2069 } 2070 } 2071 2072 static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit) 2073 { 2074 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 2075 void *cmd_data = local_cmd_data; 2076 size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 2077 if (cmd_size > sizeof(local_cmd_data)) { 2078 cmd_data = malloc(cmd_size); 2079 if (!cmd_data) 2080 cmd_size = 0; 2081 } 2082 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0; 2083 2084 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 2085 if (cmd_size) { 2086 vn_encode_vkGetImageSparseMemoryRequirements2(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 2087 vn_instance_submit_command(vn_instance, submit); 2088 if (cmd_data != local_cmd_data) 2089 free(cmd_data); 2090 } 2091 } 2092 2093 static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit) 2094 { 2095 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; 2096 void *cmd_data = local_cmd_data; 2097 size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); 2098 if (cmd_size > sizeof(local_cmd_data)) { 2099 cmd_data = malloc(cmd_size); 2100 if (!cmd_data) 2101 cmd_size = 0; 2102 } 2103 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0; 2104 2105 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); 2106 if (cmd_size) { 2107 vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(enc, cmd_flags, device, image, pProperties); 2108 vn_instance_submit_command(vn_instance, submit); 2109 if (cmd_data != local_cmd_data) 2110 free(cmd_data); 2111 } 2112 } 2113 2114 static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 2115 { 2116 VN_TRACE_FUNC(); 2117 2118 struct vn_instance_submit_command submit; 2119 vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit); 2120 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2121 if (dec) { 2122 vn_decode_vkGetImageMemoryRequirements_reply(dec, device, image, pMemoryRequirements); 2123 vn_instance_free_command_reply(vn_instance, &submit); 2124 } 2125 } 2126 2127 static inline void vn_async_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 2128 { 2129 struct vn_instance_submit_command submit; 2130 vn_submit_vkGetImageMemoryRequirements(vn_instance, 0, device, image, pMemoryRequirements, &submit); 2131 } 2132 2133 static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 2134 { 2135 VN_TRACE_FUNC(); 2136 2137 struct vn_instance_submit_command submit; 2138 vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit); 2139 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2140 if (dec) { 2141 const VkResult ret = vn_decode_vkBindImageMemory_reply(dec, device, image, memory, memoryOffset); 2142 vn_instance_free_command_reply(vn_instance, &submit); 2143 return ret; 2144 } else { 2145 return VK_ERROR_OUT_OF_HOST_MEMORY; 2146 } 2147 } 2148 2149 static inline void vn_async_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 2150 { 2151 struct vn_instance_submit_command submit; 2152 vn_submit_vkBindImageMemory(vn_instance, 0, device, image, memory, memoryOffset, &submit); 2153 } 2154 2155 static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 2156 { 2157 VN_TRACE_FUNC(); 2158 2159 struct vn_instance_submit_command submit; 2160 vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); 2161 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2162 if (dec) { 2163 vn_decode_vkGetImageSparseMemoryRequirements_reply(dec, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 2164 vn_instance_free_command_reply(vn_instance, &submit); 2165 } 2166 } 2167 2168 static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 2169 { 2170 struct vn_instance_submit_command submit; 2171 vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); 2172 } 2173 2174 static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 2175 { 2176 VN_TRACE_FUNC(); 2177 2178 struct vn_instance_submit_command submit; 2179 vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit); 2180 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2181 if (dec) { 2182 const VkResult ret = vn_decode_vkCreateImage_reply(dec, device, pCreateInfo, pAllocator, pImage); 2183 vn_instance_free_command_reply(vn_instance, &submit); 2184 return ret; 2185 } else { 2186 return VK_ERROR_OUT_OF_HOST_MEMORY; 2187 } 2188 } 2189 2190 static inline void vn_async_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 2191 { 2192 struct vn_instance_submit_command submit; 2193 vn_submit_vkCreateImage(vn_instance, 0, device, pCreateInfo, pAllocator, pImage, &submit); 2194 } 2195 2196 static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 2197 { 2198 VN_TRACE_FUNC(); 2199 2200 struct vn_instance_submit_command submit; 2201 vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit); 2202 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2203 if (dec) { 2204 vn_decode_vkDestroyImage_reply(dec, device, image, pAllocator); 2205 vn_instance_free_command_reply(vn_instance, &submit); 2206 } 2207 } 2208 2209 static inline void vn_async_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 2210 { 2211 struct vn_instance_submit_command submit; 2212 vn_submit_vkDestroyImage(vn_instance, 0, device, image, pAllocator, &submit); 2213 } 2214 2215 static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 2216 { 2217 VN_TRACE_FUNC(); 2218 2219 struct vn_instance_submit_command submit; 2220 vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit); 2221 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2222 if (dec) { 2223 vn_decode_vkGetImageSubresourceLayout_reply(dec, device, image, pSubresource, pLayout); 2224 vn_instance_free_command_reply(vn_instance, &submit); 2225 } 2226 } 2227 2228 static inline void vn_async_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 2229 { 2230 struct vn_instance_submit_command submit; 2231 vn_submit_vkGetImageSubresourceLayout(vn_instance, 0, device, image, pSubresource, pLayout, &submit); 2232 } 2233 2234 static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) 2235 { 2236 VN_TRACE_FUNC(); 2237 2238 struct vn_instance_submit_command submit; 2239 vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit); 2240 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2241 if (dec) { 2242 const VkResult ret = vn_decode_vkBindImageMemory2_reply(dec, device, bindInfoCount, pBindInfos); 2243 vn_instance_free_command_reply(vn_instance, &submit); 2244 return ret; 2245 } else { 2246 return VK_ERROR_OUT_OF_HOST_MEMORY; 2247 } 2248 } 2249 2250 static inline void vn_async_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) 2251 { 2252 struct vn_instance_submit_command submit; 2253 vn_submit_vkBindImageMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit); 2254 } 2255 2256 static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) 2257 { 2258 VN_TRACE_FUNC(); 2259 2260 struct vn_instance_submit_command submit; 2261 vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit); 2262 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2263 if (dec) { 2264 vn_decode_vkGetImageMemoryRequirements2_reply(dec, device, pInfo, pMemoryRequirements); 2265 vn_instance_free_command_reply(vn_instance, &submit); 2266 } 2267 } 2268 2269 static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) 2270 { 2271 struct vn_instance_submit_command submit; 2272 vn_submit_vkGetImageMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit); 2273 } 2274 2275 static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 2276 { 2277 VN_TRACE_FUNC(); 2278 2279 struct vn_instance_submit_command submit; 2280 vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); 2281 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2282 if (dec) { 2283 vn_decode_vkGetImageSparseMemoryRequirements2_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 2284 vn_instance_free_command_reply(vn_instance, &submit); 2285 } 2286 } 2287 2288 static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 2289 { 2290 struct vn_instance_submit_command submit; 2291 vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); 2292 } 2293 2294 static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) 2295 { 2296 VN_TRACE_FUNC(); 2297 2298 struct vn_instance_submit_command submit; 2299 vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit); 2300 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); 2301 if (dec) { 2302 const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(dec, device, image, pProperties); 2303 vn_instance_free_command_reply(vn_instance, &submit); 2304 return ret; 2305 } else { 2306 return VK_ERROR_OUT_OF_HOST_MEMORY; 2307 } 2308 } 2309 2310 static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) 2311 { 2312 struct vn_instance_submit_command submit; 2313 vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, 0, device, image, pProperties, &submit); 2314 } 2315 2316 #endif /* VN_PROTOCOL_DRIVER_IMAGE_H */ 2317
Indexes created Sat Aug 01 00:24:56 UTC 2026