1
/* This file is generated by venus-protocol. See vn_protocol_driver.h. */
4
* Copyright 2020 Google LLC
5
* SPDX-License-Identifier: MIT
8
#ifndef VN_PROTOCOL_DRIVER_QUEUE_H
9
#define VN_PROTOCOL_DRIVER_QUEUE_H
11
#include "vn_instance.h"
12
#include "vn_protocol_driver_structs.h"
14
/* struct VkDeviceGroupSubmitInfo chain */
17
vn_sizeof_VkDeviceGroupSubmitInfo_pnext(const void *val)
19
/* no known/supported struct */
20
return vn_sizeof_simple_pointer(NULL);
24
vn_sizeof_VkDeviceGroupSubmitInfo_self(const VkDeviceGroupSubmitInfo *val)
27
/* skip val->{sType,pNext} */
28
size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
29
if (val->pWaitSemaphoreDeviceIndices) {
30
size += vn_sizeof_array_size(val->waitSemaphoreCount);
31
size += vn_sizeof_uint32_t_array(val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount);
33
size += vn_sizeof_array_size(0);
35
size += vn_sizeof_uint32_t(&val->commandBufferCount);
36
if (val->pCommandBufferDeviceMasks) {
37
size += vn_sizeof_array_size(val->commandBufferCount);
38
size += vn_sizeof_uint32_t_array(val->pCommandBufferDeviceMasks, val->commandBufferCount);
40
size += vn_sizeof_array_size(0);
42
size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
43
if (val->pSignalSemaphoreDeviceIndices) {
44
size += vn_sizeof_array_size(val->signalSemaphoreCount);
45
size += vn_sizeof_uint32_t_array(val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount);
47
size += vn_sizeof_array_size(0);
53
vn_sizeof_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo *val)
57
size += vn_sizeof_VkStructureType(&val->sType);
58
size += vn_sizeof_VkDeviceGroupSubmitInfo_pnext(val->pNext);
59
size += vn_sizeof_VkDeviceGroupSubmitInfo_self(val);
65
vn_encode_VkDeviceGroupSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
67
/* no known/supported struct */
68
vn_encode_simple_pointer(enc, NULL);
72
vn_encode_VkDeviceGroupSubmitInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val)
74
/* skip val->{sType,pNext} */
75
vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
76
if (val->pWaitSemaphoreDeviceIndices) {
77
vn_encode_array_size(enc, val->waitSemaphoreCount);
78
vn_encode_uint32_t_array(enc, val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount);
80
vn_encode_array_size(enc, 0);
82
vn_encode_uint32_t(enc, &val->commandBufferCount);
83
if (val->pCommandBufferDeviceMasks) {
84
vn_encode_array_size(enc, val->commandBufferCount);
85
vn_encode_uint32_t_array(enc, val->pCommandBufferDeviceMasks, val->commandBufferCount);
87
vn_encode_array_size(enc, 0);
89
vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
90
if (val->pSignalSemaphoreDeviceIndices) {
91
vn_encode_array_size(enc, val->signalSemaphoreCount);
92
vn_encode_uint32_t_array(enc, val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount);
94
vn_encode_array_size(enc, 0);
99
vn_encode_VkDeviceGroupSubmitInfo(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val)
101
assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO);
102
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO });
103
vn_encode_VkDeviceGroupSubmitInfo_pnext(enc, val->pNext);
104
vn_encode_VkDeviceGroupSubmitInfo_self(enc, val);
107
/* struct VkProtectedSubmitInfo chain */
110
vn_sizeof_VkProtectedSubmitInfo_pnext(const void *val)
112
/* no known/supported struct */
113
return vn_sizeof_simple_pointer(NULL);
117
vn_sizeof_VkProtectedSubmitInfo_self(const VkProtectedSubmitInfo *val)
120
/* skip val->{sType,pNext} */
121
size += vn_sizeof_VkBool32(&val->protectedSubmit);
126
vn_sizeof_VkProtectedSubmitInfo(const VkProtectedSubmitInfo *val)
130
size += vn_sizeof_VkStructureType(&val->sType);
131
size += vn_sizeof_VkProtectedSubmitInfo_pnext(val->pNext);
132
size += vn_sizeof_VkProtectedSubmitInfo_self(val);
138
vn_encode_VkProtectedSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
140
/* no known/supported struct */
141
vn_encode_simple_pointer(enc, NULL);
145
vn_encode_VkProtectedSubmitInfo_self(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val)
147
/* skip val->{sType,pNext} */
148
vn_encode_VkBool32(enc, &val->protectedSubmit);
152
vn_encode_VkProtectedSubmitInfo(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val)
154
assert(val->sType == VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO);
155
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO });
156
vn_encode_VkProtectedSubmitInfo_pnext(enc, val->pNext);
157
vn_encode_VkProtectedSubmitInfo_self(enc, val);
160
/* struct VkTimelineSemaphoreSubmitInfo chain */
163
vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(const void *val)
165
/* no known/supported struct */
166
return vn_sizeof_simple_pointer(NULL);
170
vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(const VkTimelineSemaphoreSubmitInfo *val)
173
/* skip val->{sType,pNext} */
174
size += vn_sizeof_uint32_t(&val->waitSemaphoreValueCount);
175
if (val->pWaitSemaphoreValues) {
176
size += vn_sizeof_array_size(val->waitSemaphoreValueCount);
177
size += vn_sizeof_uint64_t_array(val->pWaitSemaphoreValues, val->waitSemaphoreValueCount);
179
size += vn_sizeof_array_size(0);
181
size += vn_sizeof_uint32_t(&val->signalSemaphoreValueCount);
182
if (val->pSignalSemaphoreValues) {
183
size += vn_sizeof_array_size(val->signalSemaphoreValueCount);
184
size += vn_sizeof_uint64_t_array(val->pSignalSemaphoreValues, val->signalSemaphoreValueCount);
186
size += vn_sizeof_array_size(0);
192
vn_sizeof_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo *val)
196
size += vn_sizeof_VkStructureType(&val->sType);
197
size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(val->pNext);
198
size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(val);
204
vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
206
/* no known/supported struct */
207
vn_encode_simple_pointer(enc, NULL);
211
vn_encode_VkTimelineSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val)
213
/* skip val->{sType,pNext} */
214
vn_encode_uint32_t(enc, &val->waitSemaphoreValueCount);
215
if (val->pWaitSemaphoreValues) {
216
vn_encode_array_size(enc, val->waitSemaphoreValueCount);
217
vn_encode_uint64_t_array(enc, val->pWaitSemaphoreValues, val->waitSemaphoreValueCount);
219
vn_encode_array_size(enc, 0);
221
vn_encode_uint32_t(enc, &val->signalSemaphoreValueCount);
222
if (val->pSignalSemaphoreValues) {
223
vn_encode_array_size(enc, val->signalSemaphoreValueCount);
224
vn_encode_uint64_t_array(enc, val->pSignalSemaphoreValues, val->signalSemaphoreValueCount);
226
vn_encode_array_size(enc, 0);
231
vn_encode_VkTimelineSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val)
233
assert(val->sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO);
234
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO });
235
vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(enc, val->pNext);
236
vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, val);
239
/* struct VkSubmitInfo chain */
242
vn_sizeof_VkSubmitInfo_pnext(const void *val)
244
const VkBaseInStructure *pnext = val;
248
switch ((int32_t)pnext->sType) {
249
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
250
size += vn_sizeof_simple_pointer(pnext);
251
size += vn_sizeof_VkStructureType(&pnext->sType);
252
size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
253
size += vn_sizeof_VkDeviceGroupSubmitInfo_self((const VkDeviceGroupSubmitInfo *)pnext);
255
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
256
size += vn_sizeof_simple_pointer(pnext);
257
size += vn_sizeof_VkStructureType(&pnext->sType);
258
size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
259
size += vn_sizeof_VkProtectedSubmitInfo_self((const VkProtectedSubmitInfo *)pnext);
261
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
262
size += vn_sizeof_simple_pointer(pnext);
263
size += vn_sizeof_VkStructureType(&pnext->sType);
264
size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext);
265
size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext);
268
/* ignore unknown/unsupported struct */
271
pnext = pnext->pNext;
274
return vn_sizeof_simple_pointer(NULL);
278
vn_sizeof_VkSubmitInfo_self(const VkSubmitInfo *val)
281
/* skip val->{sType,pNext} */
282
size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
283
if (val->pWaitSemaphores) {
284
size += vn_sizeof_array_size(val->waitSemaphoreCount);
285
for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
286
size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]);
288
size += vn_sizeof_array_size(0);
290
if (val->pWaitDstStageMask) {
291
size += vn_sizeof_array_size(val->waitSemaphoreCount);
292
for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
293
size += vn_sizeof_VkFlags(&val->pWaitDstStageMask[i]);
295
size += vn_sizeof_array_size(0);
297
size += vn_sizeof_uint32_t(&val->commandBufferCount);
298
if (val->pCommandBuffers) {
299
size += vn_sizeof_array_size(val->commandBufferCount);
300
for (uint32_t i = 0; i < val->commandBufferCount; i++)
301
size += vn_sizeof_VkCommandBuffer(&val->pCommandBuffers[i]);
303
size += vn_sizeof_array_size(0);
305
size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
306
if (val->pSignalSemaphores) {
307
size += vn_sizeof_array_size(val->signalSemaphoreCount);
308
for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
309
size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]);
311
size += vn_sizeof_array_size(0);
317
vn_sizeof_VkSubmitInfo(const VkSubmitInfo *val)
321
size += vn_sizeof_VkStructureType(&val->sType);
322
size += vn_sizeof_VkSubmitInfo_pnext(val->pNext);
323
size += vn_sizeof_VkSubmitInfo_self(val);
329
vn_encode_VkSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
331
const VkBaseInStructure *pnext = val;
334
switch ((int32_t)pnext->sType) {
335
case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
336
vn_encode_simple_pointer(enc, pnext);
337
vn_encode_VkStructureType(enc, &pnext->sType);
338
vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
339
vn_encode_VkDeviceGroupSubmitInfo_self(enc, (const VkDeviceGroupSubmitInfo *)pnext);
341
case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
342
vn_encode_simple_pointer(enc, pnext);
343
vn_encode_VkStructureType(enc, &pnext->sType);
344
vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
345
vn_encode_VkProtectedSubmitInfo_self(enc, (const VkProtectedSubmitInfo *)pnext);
347
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
348
vn_encode_simple_pointer(enc, pnext);
349
vn_encode_VkStructureType(enc, &pnext->sType);
350
vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext);
351
vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext);
354
/* ignore unknown/unsupported struct */
357
pnext = pnext->pNext;
360
vn_encode_simple_pointer(enc, NULL);
364
vn_encode_VkSubmitInfo_self(struct vn_cs_encoder *enc, const VkSubmitInfo *val)
366
/* skip val->{sType,pNext} */
367
vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
368
if (val->pWaitSemaphores) {
369
vn_encode_array_size(enc, val->waitSemaphoreCount);
370
for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
371
vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]);
373
vn_encode_array_size(enc, 0);
375
if (val->pWaitDstStageMask) {
376
vn_encode_array_size(enc, val->waitSemaphoreCount);
377
for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
378
vn_encode_VkFlags(enc, &val->pWaitDstStageMask[i]);
380
vn_encode_array_size(enc, 0);
382
vn_encode_uint32_t(enc, &val->commandBufferCount);
383
if (val->pCommandBuffers) {
384
vn_encode_array_size(enc, val->commandBufferCount);
385
for (uint32_t i = 0; i < val->commandBufferCount; i++)
386
vn_encode_VkCommandBuffer(enc, &val->pCommandBuffers[i]);
388
vn_encode_array_size(enc, 0);
390
vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
391
if (val->pSignalSemaphores) {
392
vn_encode_array_size(enc, val->signalSemaphoreCount);
393
for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
394
vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]);
396
vn_encode_array_size(enc, 0);
401
vn_encode_VkSubmitInfo(struct vn_cs_encoder *enc, const VkSubmitInfo *val)
403
assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO);
404
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO });
405
vn_encode_VkSubmitInfo_pnext(enc, val->pNext);
406
vn_encode_VkSubmitInfo_self(enc, val);
409
/* struct VkSparseMemoryBind */
412
vn_sizeof_VkSparseMemoryBind(const VkSparseMemoryBind *val)
415
size += vn_sizeof_VkDeviceSize(&val->resourceOffset);
416
size += vn_sizeof_VkDeviceSize(&val->size);
417
size += vn_sizeof_VkDeviceMemory(&val->memory);
418
size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
419
size += vn_sizeof_VkFlags(&val->flags);
424
vn_encode_VkSparseMemoryBind(struct vn_cs_encoder *enc, const VkSparseMemoryBind *val)
426
vn_encode_VkDeviceSize(enc, &val->resourceOffset);
427
vn_encode_VkDeviceSize(enc, &val->size);
428
vn_encode_VkDeviceMemory(enc, &val->memory);
429
vn_encode_VkDeviceSize(enc, &val->memoryOffset);
430
vn_encode_VkFlags(enc, &val->flags);
433
/* struct VkSparseBufferMemoryBindInfo */
436
vn_sizeof_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo *val)
439
size += vn_sizeof_VkBuffer(&val->buffer);
440
size += vn_sizeof_uint32_t(&val->bindCount);
442
size += vn_sizeof_array_size(val->bindCount);
443
for (uint32_t i = 0; i < val->bindCount; i++)
444
size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]);
446
size += vn_sizeof_array_size(0);
452
vn_encode_VkSparseBufferMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseBufferMemoryBindInfo *val)
454
vn_encode_VkBuffer(enc, &val->buffer);
455
vn_encode_uint32_t(enc, &val->bindCount);
457
vn_encode_array_size(enc, val->bindCount);
458
for (uint32_t i = 0; i < val->bindCount; i++)
459
vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]);
461
vn_encode_array_size(enc, 0);
465
/* struct VkSparseImageOpaqueMemoryBindInfo */
468
vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo *val)
471
size += vn_sizeof_VkImage(&val->image);
472
size += vn_sizeof_uint32_t(&val->bindCount);
474
size += vn_sizeof_array_size(val->bindCount);
475
for (uint32_t i = 0; i < val->bindCount; i++)
476
size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]);
478
size += vn_sizeof_array_size(0);
484
vn_encode_VkSparseImageOpaqueMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageOpaqueMemoryBindInfo *val)
486
vn_encode_VkImage(enc, &val->image);
487
vn_encode_uint32_t(enc, &val->bindCount);
489
vn_encode_array_size(enc, val->bindCount);
490
for (uint32_t i = 0; i < val->bindCount; i++)
491
vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]);
493
vn_encode_array_size(enc, 0);
497
/* struct VkSparseImageMemoryBind */
500
vn_sizeof_VkSparseImageMemoryBind(const VkSparseImageMemoryBind *val)
503
size += vn_sizeof_VkImageSubresource(&val->subresource);
504
size += vn_sizeof_VkOffset3D(&val->offset);
505
size += vn_sizeof_VkExtent3D(&val->extent);
506
size += vn_sizeof_VkDeviceMemory(&val->memory);
507
size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
508
size += vn_sizeof_VkFlags(&val->flags);
513
vn_encode_VkSparseImageMemoryBind(struct vn_cs_encoder *enc, const VkSparseImageMemoryBind *val)
515
vn_encode_VkImageSubresource(enc, &val->subresource);
516
vn_encode_VkOffset3D(enc, &val->offset);
517
vn_encode_VkExtent3D(enc, &val->extent);
518
vn_encode_VkDeviceMemory(enc, &val->memory);
519
vn_encode_VkDeviceSize(enc, &val->memoryOffset);
520
vn_encode_VkFlags(enc, &val->flags);
523
/* struct VkSparseImageMemoryBindInfo */
526
vn_sizeof_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo *val)
529
size += vn_sizeof_VkImage(&val->image);
530
size += vn_sizeof_uint32_t(&val->bindCount);
532
size += vn_sizeof_array_size(val->bindCount);
533
for (uint32_t i = 0; i < val->bindCount; i++)
534
size += vn_sizeof_VkSparseImageMemoryBind(&val->pBinds[i]);
536
size += vn_sizeof_array_size(0);
542
vn_encode_VkSparseImageMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageMemoryBindInfo *val)
544
vn_encode_VkImage(enc, &val->image);
545
vn_encode_uint32_t(enc, &val->bindCount);
547
vn_encode_array_size(enc, val->bindCount);
548
for (uint32_t i = 0; i < val->bindCount; i++)
549
vn_encode_VkSparseImageMemoryBind(enc, &val->pBinds[i]);
551
vn_encode_array_size(enc, 0);
555
/* struct VkDeviceGroupBindSparseInfo chain */
558
vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(const void *val)
560
/* no known/supported struct */
561
return vn_sizeof_simple_pointer(NULL);
565
vn_sizeof_VkDeviceGroupBindSparseInfo_self(const VkDeviceGroupBindSparseInfo *val)
568
/* skip val->{sType,pNext} */
569
size += vn_sizeof_uint32_t(&val->resourceDeviceIndex);
570
size += vn_sizeof_uint32_t(&val->memoryDeviceIndex);
575
vn_sizeof_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo *val)
579
size += vn_sizeof_VkStructureType(&val->sType);
580
size += vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(val->pNext);
581
size += vn_sizeof_VkDeviceGroupBindSparseInfo_self(val);
587
vn_encode_VkDeviceGroupBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val)
589
/* no known/supported struct */
590
vn_encode_simple_pointer(enc, NULL);
594
vn_encode_VkDeviceGroupBindSparseInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val)
596
/* skip val->{sType,pNext} */
597
vn_encode_uint32_t(enc, &val->resourceDeviceIndex);
598
vn_encode_uint32_t(enc, &val->memoryDeviceIndex);
602
vn_encode_VkDeviceGroupBindSparseInfo(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val)
604
assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO);
605
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO });
606
vn_encode_VkDeviceGroupBindSparseInfo_pnext(enc, val->pNext);
607
vn_encode_VkDeviceGroupBindSparseInfo_self(enc, val);
610
/* struct VkBindSparseInfo chain */
613
vn_sizeof_VkBindSparseInfo_pnext(const void *val)
615
const VkBaseInStructure *pnext = val;
619
switch ((int32_t)pnext->sType) {
620
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
621
size += vn_sizeof_simple_pointer(pnext);
622
size += vn_sizeof_VkStructureType(&pnext->sType);
623
size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext);
624
size += vn_sizeof_VkDeviceGroupBindSparseInfo_self((const VkDeviceGroupBindSparseInfo *)pnext);
626
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
627
size += vn_sizeof_simple_pointer(pnext);
628
size += vn_sizeof_VkStructureType(&pnext->sType);
629
size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext);
630
size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext);
633
/* ignore unknown/unsupported struct */
636
pnext = pnext->pNext;
639
return vn_sizeof_simple_pointer(NULL);
643
vn_sizeof_VkBindSparseInfo_self(const VkBindSparseInfo *val)
646
/* skip val->{sType,pNext} */
647
size += vn_sizeof_uint32_t(&val->waitSemaphoreCount);
648
if (val->pWaitSemaphores) {
649
size += vn_sizeof_array_size(val->waitSemaphoreCount);
650
for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
651
size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]);
653
size += vn_sizeof_array_size(0);
655
size += vn_sizeof_uint32_t(&val->bufferBindCount);
656
if (val->pBufferBinds) {
657
size += vn_sizeof_array_size(val->bufferBindCount);
658
for (uint32_t i = 0; i < val->bufferBindCount; i++)
659
size += vn_sizeof_VkSparseBufferMemoryBindInfo(&val->pBufferBinds[i]);
661
size += vn_sizeof_array_size(0);
663
size += vn_sizeof_uint32_t(&val->imageOpaqueBindCount);
664
if (val->pImageOpaqueBinds) {
665
size += vn_sizeof_array_size(val->imageOpaqueBindCount);
666
for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++)
667
size += vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(&val->pImageOpaqueBinds[i]);
669
size += vn_sizeof_array_size(0);
671
size += vn_sizeof_uint32_t(&val->imageBindCount);
672
if (val->pImageBinds) {
673
size += vn_sizeof_array_size(val->imageBindCount);
674
for (uint32_t i = 0; i < val->imageBindCount; i++)
675
size += vn_sizeof_VkSparseImageMemoryBindInfo(&val->pImageBinds[i]);
677
size += vn_sizeof_array_size(0);
679
size += vn_sizeof_uint32_t(&val->signalSemaphoreCount);
680
if (val->pSignalSemaphores) {
681
size += vn_sizeof_array_size(val->signalSemaphoreCount);
682
for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
683
size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]);
685
size += vn_sizeof_array_size(0);
691
vn_sizeof_VkBindSparseInfo(const VkBindSparseInfo *val)
695
size += vn_sizeof_VkStructureType(&val->sType);
696
size += vn_sizeof_VkBindSparseInfo_pnext(val->pNext);
697
size += vn_sizeof_VkBindSparseInfo_self(val);
703
vn_encode_VkBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val)
705
const VkBaseInStructure *pnext = val;
708
switch ((int32_t)pnext->sType) {
709
case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
710
vn_encode_simple_pointer(enc, pnext);
711
vn_encode_VkStructureType(enc, &pnext->sType);
712
vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext);
713
vn_encode_VkDeviceGroupBindSparseInfo_self(enc, (const VkDeviceGroupBindSparseInfo *)pnext);
715
case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
716
vn_encode_simple_pointer(enc, pnext);
717
vn_encode_VkStructureType(enc, &pnext->sType);
718
vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext);
719
vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext);
722
/* ignore unknown/unsupported struct */
725
pnext = pnext->pNext;
728
vn_encode_simple_pointer(enc, NULL);
732
vn_encode_VkBindSparseInfo_self(struct vn_cs_encoder *enc, const VkBindSparseInfo *val)
734
/* skip val->{sType,pNext} */
735
vn_encode_uint32_t(enc, &val->waitSemaphoreCount);
736
if (val->pWaitSemaphores) {
737
vn_encode_array_size(enc, val->waitSemaphoreCount);
738
for (uint32_t i = 0; i < val->waitSemaphoreCount; i++)
739
vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]);
741
vn_encode_array_size(enc, 0);
743
vn_encode_uint32_t(enc, &val->bufferBindCount);
744
if (val->pBufferBinds) {
745
vn_encode_array_size(enc, val->bufferBindCount);
746
for (uint32_t i = 0; i < val->bufferBindCount; i++)
747
vn_encode_VkSparseBufferMemoryBindInfo(enc, &val->pBufferBinds[i]);
749
vn_encode_array_size(enc, 0);
751
vn_encode_uint32_t(enc, &val->imageOpaqueBindCount);
752
if (val->pImageOpaqueBinds) {
753
vn_encode_array_size(enc, val->imageOpaqueBindCount);
754
for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++)
755
vn_encode_VkSparseImageOpaqueMemoryBindInfo(enc, &val->pImageOpaqueBinds[i]);
757
vn_encode_array_size(enc, 0);
759
vn_encode_uint32_t(enc, &val->imageBindCount);
760
if (val->pImageBinds) {
761
vn_encode_array_size(enc, val->imageBindCount);
762
for (uint32_t i = 0; i < val->imageBindCount; i++)
763
vn_encode_VkSparseImageMemoryBindInfo(enc, &val->pImageBinds[i]);
765
vn_encode_array_size(enc, 0);
767
vn_encode_uint32_t(enc, &val->signalSemaphoreCount);
768
if (val->pSignalSemaphores) {
769
vn_encode_array_size(enc, val->signalSemaphoreCount);
770
for (uint32_t i = 0; i < val->signalSemaphoreCount; i++)
771
vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]);
773
vn_encode_array_size(enc, 0);
778
vn_encode_VkBindSparseInfo(struct vn_cs_encoder *enc, const VkBindSparseInfo *val)
780
assert(val->sType == VK_STRUCTURE_TYPE_BIND_SPARSE_INFO);
781
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO });
782
vn_encode_VkBindSparseInfo_pnext(enc, val->pNext);
783
vn_encode_VkBindSparseInfo_self(enc, val);
786
/* struct VkSemaphoreSubmitInfo chain */
789
vn_sizeof_VkSemaphoreSubmitInfo_pnext(const void *val)
791
/* no known/supported struct */
792
return vn_sizeof_simple_pointer(NULL);
796
vn_sizeof_VkSemaphoreSubmitInfo_self(const VkSemaphoreSubmitInfo *val)
799
/* skip val->{sType,pNext} */
800
size += vn_sizeof_VkSemaphore(&val->semaphore);
801
size += vn_sizeof_uint64_t(&val->value);
802
size += vn_sizeof_VkFlags64(&val->stageMask);
803
size += vn_sizeof_uint32_t(&val->deviceIndex);
808
vn_sizeof_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo *val)
812
size += vn_sizeof_VkStructureType(&val->sType);
813
size += vn_sizeof_VkSemaphoreSubmitInfo_pnext(val->pNext);
814
size += vn_sizeof_VkSemaphoreSubmitInfo_self(val);
820
vn_encode_VkSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
822
/* no known/supported struct */
823
vn_encode_simple_pointer(enc, NULL);
827
vn_encode_VkSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSubmitInfo *val)
829
/* skip val->{sType,pNext} */
830
vn_encode_VkSemaphore(enc, &val->semaphore);
831
vn_encode_uint64_t(enc, &val->value);
832
vn_encode_VkFlags64(enc, &val->stageMask);
833
vn_encode_uint32_t(enc, &val->deviceIndex);
837
vn_encode_VkSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkSemaphoreSubmitInfo *val)
839
assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO);
840
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO });
841
vn_encode_VkSemaphoreSubmitInfo_pnext(enc, val->pNext);
842
vn_encode_VkSemaphoreSubmitInfo_self(enc, val);
845
/* struct VkCommandBufferSubmitInfo chain */
848
vn_sizeof_VkCommandBufferSubmitInfo_pnext(const void *val)
850
/* no known/supported struct */
851
return vn_sizeof_simple_pointer(NULL);
855
vn_sizeof_VkCommandBufferSubmitInfo_self(const VkCommandBufferSubmitInfo *val)
858
/* skip val->{sType,pNext} */
859
size += vn_sizeof_VkCommandBuffer(&val->commandBuffer);
860
size += vn_sizeof_uint32_t(&val->deviceMask);
865
vn_sizeof_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo *val)
869
size += vn_sizeof_VkStructureType(&val->sType);
870
size += vn_sizeof_VkCommandBufferSubmitInfo_pnext(val->pNext);
871
size += vn_sizeof_VkCommandBufferSubmitInfo_self(val);
877
vn_encode_VkCommandBufferSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
879
/* no known/supported struct */
880
vn_encode_simple_pointer(enc, NULL);
884
vn_encode_VkCommandBufferSubmitInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferSubmitInfo *val)
886
/* skip val->{sType,pNext} */
887
vn_encode_VkCommandBuffer(enc, &val->commandBuffer);
888
vn_encode_uint32_t(enc, &val->deviceMask);
892
vn_encode_VkCommandBufferSubmitInfo(struct vn_cs_encoder *enc, const VkCommandBufferSubmitInfo *val)
894
assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO);
895
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO });
896
vn_encode_VkCommandBufferSubmitInfo_pnext(enc, val->pNext);
897
vn_encode_VkCommandBufferSubmitInfo_self(enc, val);
900
/* struct VkSubmitInfo2 chain */
903
vn_sizeof_VkSubmitInfo2_pnext(const void *val)
905
/* no known/supported struct */
906
return vn_sizeof_simple_pointer(NULL);
910
vn_sizeof_VkSubmitInfo2_self(const VkSubmitInfo2 *val)
913
/* skip val->{sType,pNext} */
914
size += vn_sizeof_VkFlags(&val->flags);
915
size += vn_sizeof_uint32_t(&val->waitSemaphoreInfoCount);
916
if (val->pWaitSemaphoreInfos) {
917
size += vn_sizeof_array_size(val->waitSemaphoreInfoCount);
918
for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++)
919
size += vn_sizeof_VkSemaphoreSubmitInfo(&val->pWaitSemaphoreInfos[i]);
921
size += vn_sizeof_array_size(0);
923
size += vn_sizeof_uint32_t(&val->commandBufferInfoCount);
924
if (val->pCommandBufferInfos) {
925
size += vn_sizeof_array_size(val->commandBufferInfoCount);
926
for (uint32_t i = 0; i < val->commandBufferInfoCount; i++)
927
size += vn_sizeof_VkCommandBufferSubmitInfo(&val->pCommandBufferInfos[i]);
929
size += vn_sizeof_array_size(0);
931
size += vn_sizeof_uint32_t(&val->signalSemaphoreInfoCount);
932
if (val->pSignalSemaphoreInfos) {
933
size += vn_sizeof_array_size(val->signalSemaphoreInfoCount);
934
for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++)
935
size += vn_sizeof_VkSemaphoreSubmitInfo(&val->pSignalSemaphoreInfos[i]);
937
size += vn_sizeof_array_size(0);
943
vn_sizeof_VkSubmitInfo2(const VkSubmitInfo2 *val)
947
size += vn_sizeof_VkStructureType(&val->sType);
948
size += vn_sizeof_VkSubmitInfo2_pnext(val->pNext);
949
size += vn_sizeof_VkSubmitInfo2_self(val);
955
vn_encode_VkSubmitInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
957
/* no known/supported struct */
958
vn_encode_simple_pointer(enc, NULL);
962
vn_encode_VkSubmitInfo2_self(struct vn_cs_encoder *enc, const VkSubmitInfo2 *val)
964
/* skip val->{sType,pNext} */
965
vn_encode_VkFlags(enc, &val->flags);
966
vn_encode_uint32_t(enc, &val->waitSemaphoreInfoCount);
967
if (val->pWaitSemaphoreInfos) {
968
vn_encode_array_size(enc, val->waitSemaphoreInfoCount);
969
for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++)
970
vn_encode_VkSemaphoreSubmitInfo(enc, &val->pWaitSemaphoreInfos[i]);
972
vn_encode_array_size(enc, 0);
974
vn_encode_uint32_t(enc, &val->commandBufferInfoCount);
975
if (val->pCommandBufferInfos) {
976
vn_encode_array_size(enc, val->commandBufferInfoCount);
977
for (uint32_t i = 0; i < val->commandBufferInfoCount; i++)
978
vn_encode_VkCommandBufferSubmitInfo(enc, &val->pCommandBufferInfos[i]);
980
vn_encode_array_size(enc, 0);
982
vn_encode_uint32_t(enc, &val->signalSemaphoreInfoCount);
983
if (val->pSignalSemaphoreInfos) {
984
vn_encode_array_size(enc, val->signalSemaphoreInfoCount);
985
for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++)
986
vn_encode_VkSemaphoreSubmitInfo(enc, &val->pSignalSemaphoreInfos[i]);
988
vn_encode_array_size(enc, 0);
993
vn_encode_VkSubmitInfo2(struct vn_cs_encoder *enc, const VkSubmitInfo2 *val)
995
assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO_2);
996
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO_2 });
997
vn_encode_VkSubmitInfo2_pnext(enc, val->pNext);
998
vn_encode_VkSubmitInfo2_self(enc, val);
1001
static inline size_t vn_sizeof_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
1003
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
1004
const VkFlags cmd_flags = 0;
1005
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1007
cmd_size += vn_sizeof_VkQueue(&queue);
1008
cmd_size += vn_sizeof_uint32_t(&submitCount);
1010
cmd_size += vn_sizeof_array_size(submitCount);
1011
for (uint32_t i = 0; i < submitCount; i++)
1012
cmd_size += vn_sizeof_VkSubmitInfo(&pSubmits[i]);
1014
cmd_size += vn_sizeof_array_size(0);
1016
cmd_size += vn_sizeof_VkFence(&fence);
1021
static inline void vn_encode_vkQueueSubmit(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
1023
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
1025
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1026
vn_encode_VkFlags(enc, &cmd_flags);
1028
vn_encode_VkQueue(enc, &queue);
1029
vn_encode_uint32_t(enc, &submitCount);
1031
vn_encode_array_size(enc, submitCount);
1032
for (uint32_t i = 0; i < submitCount; i++)
1033
vn_encode_VkSubmitInfo(enc, &pSubmits[i]);
1035
vn_encode_array_size(enc, 0);
1037
vn_encode_VkFence(enc, &fence);
1040
static inline size_t vn_sizeof_vkQueueSubmit_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
1042
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
1043
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1046
cmd_size += vn_sizeof_VkResult(&ret);
1048
/* skip submitCount */
1055
static inline VkResult vn_decode_vkQueueSubmit_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
1057
VkCommandTypeEXT command_type;
1058
vn_decode_VkCommandTypeEXT(dec, &command_type);
1059
assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit_EXT);
1062
vn_decode_VkResult(dec, &ret);
1064
/* skip submitCount */
1071
static inline size_t vn_sizeof_vkQueueWaitIdle(VkQueue queue)
1073
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
1074
const VkFlags cmd_flags = 0;
1075
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1077
cmd_size += vn_sizeof_VkQueue(&queue);
1082
static inline void vn_encode_vkQueueWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue)
1084
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
1086
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1087
vn_encode_VkFlags(enc, &cmd_flags);
1089
vn_encode_VkQueue(enc, &queue);
1092
static inline size_t vn_sizeof_vkQueueWaitIdle_reply(VkQueue queue)
1094
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT;
1095
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1098
cmd_size += vn_sizeof_VkResult(&ret);
1104
static inline VkResult vn_decode_vkQueueWaitIdle_reply(struct vn_cs_decoder *dec, VkQueue queue)
1106
VkCommandTypeEXT command_type;
1107
vn_decode_VkCommandTypeEXT(dec, &command_type);
1108
assert(command_type == VK_COMMAND_TYPE_vkQueueWaitIdle_EXT);
1111
vn_decode_VkResult(dec, &ret);
1117
static inline size_t vn_sizeof_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
1119
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
1120
const VkFlags cmd_flags = 0;
1121
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1123
cmd_size += vn_sizeof_VkQueue(&queue);
1124
cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
1126
cmd_size += vn_sizeof_array_size(bindInfoCount);
1127
for (uint32_t i = 0; i < bindInfoCount; i++)
1128
cmd_size += vn_sizeof_VkBindSparseInfo(&pBindInfo[i]);
1130
cmd_size += vn_sizeof_array_size(0);
1132
cmd_size += vn_sizeof_VkFence(&fence);
1137
static inline void vn_encode_vkQueueBindSparse(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
1139
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
1141
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1142
vn_encode_VkFlags(enc, &cmd_flags);
1144
vn_encode_VkQueue(enc, &queue);
1145
vn_encode_uint32_t(enc, &bindInfoCount);
1147
vn_encode_array_size(enc, bindInfoCount);
1148
for (uint32_t i = 0; i < bindInfoCount; i++)
1149
vn_encode_VkBindSparseInfo(enc, &pBindInfo[i]);
1151
vn_encode_array_size(enc, 0);
1153
vn_encode_VkFence(enc, &fence);
1156
static inline size_t vn_sizeof_vkQueueBindSparse_reply(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
1158
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT;
1159
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1162
cmd_size += vn_sizeof_VkResult(&ret);
1164
/* skip bindInfoCount */
1165
/* skip pBindInfo */
1171
static inline VkResult vn_decode_vkQueueBindSparse_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
1173
VkCommandTypeEXT command_type;
1174
vn_decode_VkCommandTypeEXT(dec, &command_type);
1175
assert(command_type == VK_COMMAND_TYPE_vkQueueBindSparse_EXT);
1178
vn_decode_VkResult(dec, &ret);
1180
/* skip bindInfoCount */
1181
/* skip pBindInfo */
1187
static inline size_t vn_sizeof_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1189
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT;
1190
const VkFlags cmd_flags = 0;
1191
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1193
cmd_size += vn_sizeof_VkQueue(&queue);
1194
cmd_size += vn_sizeof_uint32_t(&submitCount);
1196
cmd_size += vn_sizeof_array_size(submitCount);
1197
for (uint32_t i = 0; i < submitCount; i++)
1198
cmd_size += vn_sizeof_VkSubmitInfo2(&pSubmits[i]);
1200
cmd_size += vn_sizeof_array_size(0);
1202
cmd_size += vn_sizeof_VkFence(&fence);
1207
static inline void vn_encode_vkQueueSubmit2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1209
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT;
1211
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1212
vn_encode_VkFlags(enc, &cmd_flags);
1214
vn_encode_VkQueue(enc, &queue);
1215
vn_encode_uint32_t(enc, &submitCount);
1217
vn_encode_array_size(enc, submitCount);
1218
for (uint32_t i = 0; i < submitCount; i++)
1219
vn_encode_VkSubmitInfo2(enc, &pSubmits[i]);
1221
vn_encode_array_size(enc, 0);
1223
vn_encode_VkFence(enc, &fence);
1226
static inline size_t vn_sizeof_vkQueueSubmit2_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1228
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT;
1229
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1232
cmd_size += vn_sizeof_VkResult(&ret);
1234
/* skip submitCount */
1241
static inline VkResult vn_decode_vkQueueSubmit2_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1243
VkCommandTypeEXT command_type;
1244
vn_decode_VkCommandTypeEXT(dec, &command_type);
1245
assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit2_EXT);
1248
vn_decode_VkResult(dec, &ret);
1250
/* skip submitCount */
1257
static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, struct vn_instance_submit_command *submit)
1259
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1260
void *cmd_data = local_cmd_data;
1261
size_t cmd_size = vn_sizeof_vkQueueSubmit(queue, submitCount, pSubmits, fence);
1262
if (cmd_size > sizeof(local_cmd_data)) {
1263
cmd_data = malloc(cmd_size);
1267
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit_reply(queue, submitCount, pSubmits, fence) : 0;
1269
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1271
vn_encode_vkQueueSubmit(enc, cmd_flags, queue, submitCount, pSubmits, fence);
1272
vn_instance_submit_command(vn_instance, submit);
1273
if (cmd_data != local_cmd_data)
1278
static inline void vn_submit_vkQueueWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, struct vn_instance_submit_command *submit)
1280
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1281
void *cmd_data = local_cmd_data;
1282
size_t cmd_size = vn_sizeof_vkQueueWaitIdle(queue);
1283
if (cmd_size > sizeof(local_cmd_data)) {
1284
cmd_data = malloc(cmd_size);
1288
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueWaitIdle_reply(queue) : 0;
1290
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1292
vn_encode_vkQueueWaitIdle(enc, cmd_flags, queue);
1293
vn_instance_submit_command(vn_instance, submit);
1294
if (cmd_data != local_cmd_data)
1299
static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, struct vn_instance_submit_command *submit)
1301
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1302
void *cmd_data = local_cmd_data;
1303
size_t cmd_size = vn_sizeof_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
1304
if (cmd_size > sizeof(local_cmd_data)) {
1305
cmd_data = malloc(cmd_size);
1309
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueBindSparse_reply(queue, bindInfoCount, pBindInfo, fence) : 0;
1311
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1313
vn_encode_vkQueueBindSparse(enc, cmd_flags, queue, bindInfoCount, pBindInfo, fence);
1314
vn_instance_submit_command(vn_instance, submit);
1315
if (cmd_data != local_cmd_data)
1320
static inline void vn_submit_vkQueueSubmit2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, struct vn_instance_submit_command *submit)
1322
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1323
void *cmd_data = local_cmd_data;
1324
size_t cmd_size = vn_sizeof_vkQueueSubmit2(queue, submitCount, pSubmits, fence);
1325
if (cmd_size > sizeof(local_cmd_data)) {
1326
cmd_data = malloc(cmd_size);
1330
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit2_reply(queue, submitCount, pSubmits, fence) : 0;
1332
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1334
vn_encode_vkQueueSubmit2(enc, cmd_flags, queue, submitCount, pSubmits, fence);
1335
vn_instance_submit_command(vn_instance, submit);
1336
if (cmd_data != local_cmd_data)
1341
static inline VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
1345
struct vn_instance_submit_command submit;
1346
vn_submit_vkQueueSubmit(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit);
1347
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1349
const VkResult ret = vn_decode_vkQueueSubmit_reply(dec, queue, submitCount, pSubmits, fence);
1350
vn_instance_free_command_reply(vn_instance, &submit);
1353
return VK_ERROR_OUT_OF_HOST_MEMORY;
1357
static inline void vn_async_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
1359
struct vn_instance_submit_command submit;
1360
vn_submit_vkQueueSubmit(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit);
1363
static inline VkResult vn_call_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue)
1367
struct vn_instance_submit_command submit;
1368
vn_submit_vkQueueWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, &submit);
1369
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1371
const VkResult ret = vn_decode_vkQueueWaitIdle_reply(dec, queue);
1372
vn_instance_free_command_reply(vn_instance, &submit);
1375
return VK_ERROR_OUT_OF_HOST_MEMORY;
1379
static inline void vn_async_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue)
1381
struct vn_instance_submit_command submit;
1382
vn_submit_vkQueueWaitIdle(vn_instance, 0, queue, &submit);
1385
static inline VkResult vn_call_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
1389
struct vn_instance_submit_command submit;
1390
vn_submit_vkQueueBindSparse(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, bindInfoCount, pBindInfo, fence, &submit);
1391
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1393
const VkResult ret = vn_decode_vkQueueBindSparse_reply(dec, queue, bindInfoCount, pBindInfo, fence);
1394
vn_instance_free_command_reply(vn_instance, &submit);
1397
return VK_ERROR_OUT_OF_HOST_MEMORY;
1401
static inline void vn_async_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
1403
struct vn_instance_submit_command submit;
1404
vn_submit_vkQueueBindSparse(vn_instance, 0, queue, bindInfoCount, pBindInfo, fence, &submit);
1407
static inline VkResult vn_call_vkQueueSubmit2(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1411
struct vn_instance_submit_command submit;
1412
vn_submit_vkQueueSubmit2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit);
1413
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1415
const VkResult ret = vn_decode_vkQueueSubmit2_reply(dec, queue, submitCount, pSubmits, fence);
1416
vn_instance_free_command_reply(vn_instance, &submit);
1419
return VK_ERROR_OUT_OF_HOST_MEMORY;
1423
static inline void vn_async_vkQueueSubmit2(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1425
struct vn_instance_submit_command submit;
1426
vn_submit_vkQueueSubmit2(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit);
1429
#endif /* VN_PROTOCOL_DRIVER_QUEUE_H */
added
removed
src/virtio/venus-protocol/vn_protocol_driver_queue.h
