Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
PojavLauncherTeam
GitHub Repository: PojavLauncherTeam/mesa
 Path: blob/21.2-virgl/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h
4560 views
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_RENDER_PASS_H

9
#define VN_PROTOCOL_DRIVER_RENDER_PASS_H

10


11
#include "vn_device.h"

12
#include "vn_protocol_driver_structs.h"

13


14
/* struct VkAttachmentDescription */

15


16
static inline size_t

17
vn_sizeof_VkAttachmentDescription(const VkAttachmentDescription *val)

18
{

19
    size_t size = 0;

20
    size += vn_sizeof_VkFlags(&val->flags);

21
    size += vn_sizeof_VkFormat(&val->format);

22
    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);

23
    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);

24
    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);

25
    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);

26
    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);

27
    size += vn_sizeof_VkImageLayout(&val->initialLayout);

28
    size += vn_sizeof_VkImageLayout(&val->finalLayout);

29
    return size;

30
}

31


32
static inline void

33
vn_encode_VkAttachmentDescription(struct vn_cs_encoder *enc, const VkAttachmentDescription *val)

34
{

35
    vn_encode_VkFlags(enc, &val->flags);

36
    vn_encode_VkFormat(enc, &val->format);

37
    vn_encode_VkSampleCountFlagBits(enc, &val->samples);

38
    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);

39
    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);

40
    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);

41
    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);

42
    vn_encode_VkImageLayout(enc, &val->initialLayout);

43
    vn_encode_VkImageLayout(enc, &val->finalLayout);

44
}

45


46
/* struct VkAttachmentReference */

47


48
static inline size_t

49
vn_sizeof_VkAttachmentReference(const VkAttachmentReference *val)

50
{

51
    size_t size = 0;

52
    size += vn_sizeof_uint32_t(&val->attachment);

53
    size += vn_sizeof_VkImageLayout(&val->layout);

54
    return size;

55
}

56


57
static inline void

58
vn_encode_VkAttachmentReference(struct vn_cs_encoder *enc, const VkAttachmentReference *val)

59
{

60
    vn_encode_uint32_t(enc, &val->attachment);

61
    vn_encode_VkImageLayout(enc, &val->layout);

62
}

63


64
/* struct VkSubpassDescription */

65


66
static inline size_t

67
vn_sizeof_VkSubpassDescription(const VkSubpassDescription *val)

68
{

69
    size_t size = 0;

70
    size += vn_sizeof_VkFlags(&val->flags);

71
    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);

72
    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);

73
    if (val->pInputAttachments) {

74
        size += vn_sizeof_array_size(val->inputAttachmentCount);

75
        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)

76
            size += vn_sizeof_VkAttachmentReference(&val->pInputAttachments[i]);

77
    } else {

78
        size += vn_sizeof_array_size(0);

79
    }

80
    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);

81
    if (val->pColorAttachments) {

82
        size += vn_sizeof_array_size(val->colorAttachmentCount);

83
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

84
            size += vn_sizeof_VkAttachmentReference(&val->pColorAttachments[i]);

85
    } else {

86
        size += vn_sizeof_array_size(0);

87
    }

88
    if (val->pResolveAttachments) {

89
        size += vn_sizeof_array_size(val->colorAttachmentCount);

90
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

91
            size += vn_sizeof_VkAttachmentReference(&val->pResolveAttachments[i]);

92
    } else {

93
        size += vn_sizeof_array_size(0);

94
    }

95
    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);

96
    if (val->pDepthStencilAttachment)

97
        size += vn_sizeof_VkAttachmentReference(val->pDepthStencilAttachment);

98
    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);

99
    if (val->pPreserveAttachments) {

100
        size += vn_sizeof_array_size(val->preserveAttachmentCount);

101
        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);

102
    } else {

103
        size += vn_sizeof_array_size(0);

104
    }

105
    return size;

106
}

107


108
static inline void

109
vn_encode_VkSubpassDescription(struct vn_cs_encoder *enc, const VkSubpassDescription *val)

110
{

111
    vn_encode_VkFlags(enc, &val->flags);

112
    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);

113
    vn_encode_uint32_t(enc, &val->inputAttachmentCount);

114
    if (val->pInputAttachments) {

115
        vn_encode_array_size(enc, val->inputAttachmentCount);

116
        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)

117
            vn_encode_VkAttachmentReference(enc, &val->pInputAttachments[i]);

118
    } else {

119
        vn_encode_array_size(enc, 0);

120
    }

121
    vn_encode_uint32_t(enc, &val->colorAttachmentCount);

122
    if (val->pColorAttachments) {

123
        vn_encode_array_size(enc, val->colorAttachmentCount);

124
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

125
            vn_encode_VkAttachmentReference(enc, &val->pColorAttachments[i]);

126
    } else {

127
        vn_encode_array_size(enc, 0);

128
    }

129
    if (val->pResolveAttachments) {

130
        vn_encode_array_size(enc, val->colorAttachmentCount);

131
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

132
            vn_encode_VkAttachmentReference(enc, &val->pResolveAttachments[i]);

133
    } else {

134
        vn_encode_array_size(enc, 0);

135
    }

136
    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))

137
        vn_encode_VkAttachmentReference(enc, val->pDepthStencilAttachment);

138
    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);

139
    if (val->pPreserveAttachments) {

140
        vn_encode_array_size(enc, val->preserveAttachmentCount);

141
        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);

142
    } else {

143
        vn_encode_array_size(enc, 0);

144
    }

145
}

146


147
/* struct VkSubpassDependency */

148


149
static inline size_t

150
vn_sizeof_VkSubpassDependency(const VkSubpassDependency *val)

151
{

152
    size_t size = 0;

153
    size += vn_sizeof_uint32_t(&val->srcSubpass);

154
    size += vn_sizeof_uint32_t(&val->dstSubpass);

155
    size += vn_sizeof_VkFlags(&val->srcStageMask);

156
    size += vn_sizeof_VkFlags(&val->dstStageMask);

157
    size += vn_sizeof_VkFlags(&val->srcAccessMask);

158
    size += vn_sizeof_VkFlags(&val->dstAccessMask);

159
    size += vn_sizeof_VkFlags(&val->dependencyFlags);

160
    return size;

161
}

162


163
static inline void

164
vn_encode_VkSubpassDependency(struct vn_cs_encoder *enc, const VkSubpassDependency *val)

165
{

166
    vn_encode_uint32_t(enc, &val->srcSubpass);

167
    vn_encode_uint32_t(enc, &val->dstSubpass);

168
    vn_encode_VkFlags(enc, &val->srcStageMask);

169
    vn_encode_VkFlags(enc, &val->dstStageMask);

170
    vn_encode_VkFlags(enc, &val->srcAccessMask);

171
    vn_encode_VkFlags(enc, &val->dstAccessMask);

172
    vn_encode_VkFlags(enc, &val->dependencyFlags);

173
}

174


175
/* struct VkRenderPassMultiviewCreateInfo chain */

176


177
static inline size_t

178
vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void *val)

179
{

180
    /* no known/supported struct */

181
    return vn_sizeof_simple_pointer(NULL);

182
}

183


184
static inline size_t

185
vn_sizeof_VkRenderPassMultiviewCreateInfo_self(const VkRenderPassMultiviewCreateInfo *val)

186
{

187
    size_t size = 0;

188
    /* skip val->{sType,pNext} */

189
    size += vn_sizeof_uint32_t(&val->subpassCount);

190
    if (val->pViewMasks) {

191
        size += vn_sizeof_array_size(val->subpassCount);

192
        size += vn_sizeof_uint32_t_array(val->pViewMasks, val->subpassCount);

193
    } else {

194
        size += vn_sizeof_array_size(0);

195
    }

196
    size += vn_sizeof_uint32_t(&val->dependencyCount);

197
    if (val->pViewOffsets) {

198
        size += vn_sizeof_array_size(val->dependencyCount);

199
        size += vn_sizeof_int32_t_array(val->pViewOffsets, val->dependencyCount);

200
    } else {

201
        size += vn_sizeof_array_size(0);

202
    }

203
    size += vn_sizeof_uint32_t(&val->correlationMaskCount);

204
    if (val->pCorrelationMasks) {

205
        size += vn_sizeof_array_size(val->correlationMaskCount);

206
        size += vn_sizeof_uint32_t_array(val->pCorrelationMasks, val->correlationMaskCount);

207
    } else {

208
        size += vn_sizeof_array_size(0);

209
    }

210
    return size;

211
}

212


213
static inline size_t

214
vn_sizeof_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo *val)

215
{

216
    size_t size = 0;

217


218
    size += vn_sizeof_VkStructureType(&val->sType);

219
    size += vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(val->pNext);

220
    size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self(val);

221


222
    return size;

223
}

224


225
static inline void

226
vn_encode_VkRenderPassMultiviewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)

227
{

228
    /* no known/supported struct */

229
    vn_encode_simple_pointer(enc, NULL);

230
}

231


232
static inline void

233
vn_encode_VkRenderPassMultiviewCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)

234
{

235
    /* skip val->{sType,pNext} */

236
    vn_encode_uint32_t(enc, &val->subpassCount);

237
    if (val->pViewMasks) {

238
        vn_encode_array_size(enc, val->subpassCount);

239
        vn_encode_uint32_t_array(enc, val->pViewMasks, val->subpassCount);

240
    } else {

241
        vn_encode_array_size(enc, 0);

242
    }

243
    vn_encode_uint32_t(enc, &val->dependencyCount);

244
    if (val->pViewOffsets) {

245
        vn_encode_array_size(enc, val->dependencyCount);

246
        vn_encode_int32_t_array(enc, val->pViewOffsets, val->dependencyCount);

247
    } else {

248
        vn_encode_array_size(enc, 0);

249
    }

250
    vn_encode_uint32_t(enc, &val->correlationMaskCount);

251
    if (val->pCorrelationMasks) {

252
        vn_encode_array_size(enc, val->correlationMaskCount);

253
        vn_encode_uint32_t_array(enc, val->pCorrelationMasks, val->correlationMaskCount);

254
    } else {

255
        vn_encode_array_size(enc, 0);

256
    }

257
}

258


259
static inline void

260
vn_encode_VkRenderPassMultiviewCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)

261
{

262
    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO);

263
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO });

264
    vn_encode_VkRenderPassMultiviewCreateInfo_pnext(enc, val->pNext);

265
    vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, val);

266
}

267


268
/* struct VkInputAttachmentAspectReference */

269


270
static inline size_t

271
vn_sizeof_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference *val)

272
{

273
    size_t size = 0;

274
    size += vn_sizeof_uint32_t(&val->subpass);

275
    size += vn_sizeof_uint32_t(&val->inputAttachmentIndex);

276
    size += vn_sizeof_VkFlags(&val->aspectMask);

277
    return size;

278
}

279


280
static inline void

281
vn_encode_VkInputAttachmentAspectReference(struct vn_cs_encoder *enc, const VkInputAttachmentAspectReference *val)

282
{

283
    vn_encode_uint32_t(enc, &val->subpass);

284
    vn_encode_uint32_t(enc, &val->inputAttachmentIndex);

285
    vn_encode_VkFlags(enc, &val->aspectMask);

286
}

287


288
/* struct VkRenderPassInputAttachmentAspectCreateInfo chain */

289


290
static inline size_t

291
vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void *val)

292
{

293
    /* no known/supported struct */

294
    return vn_sizeof_simple_pointer(NULL);

295
}

296


297
static inline size_t

298
vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(const VkRenderPassInputAttachmentAspectCreateInfo *val)

299
{

300
    size_t size = 0;

301
    /* skip val->{sType,pNext} */

302
    size += vn_sizeof_uint32_t(&val->aspectReferenceCount);

303
    if (val->pAspectReferences) {

304
        size += vn_sizeof_array_size(val->aspectReferenceCount);

305
        for (uint32_t i = 0; i < val->aspectReferenceCount; i++)

306
            size += vn_sizeof_VkInputAttachmentAspectReference(&val->pAspectReferences[i]);

307
    } else {

308
        size += vn_sizeof_array_size(0);

309
    }

310
    return size;

311
}

312


313
static inline size_t

314
vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo *val)

315
{

316
    size_t size = 0;

317


318
    size += vn_sizeof_VkStructureType(&val->sType);

319
    size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(val->pNext);

320
    size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(val);

321


322
    return size;

323
}

324


325
static inline void

326
vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)

327
{

328
    /* no known/supported struct */

329
    vn_encode_simple_pointer(enc, NULL);

330
}

331


332
static inline void

333
vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)

334
{

335
    /* skip val->{sType,pNext} */

336
    vn_encode_uint32_t(enc, &val->aspectReferenceCount);

337
    if (val->pAspectReferences) {

338
        vn_encode_array_size(enc, val->aspectReferenceCount);

339
        for (uint32_t i = 0; i < val->aspectReferenceCount; i++)

340
            vn_encode_VkInputAttachmentAspectReference(enc, &val->pAspectReferences[i]);

341
    } else {

342
        vn_encode_array_size(enc, 0);

343
    }

344
}

345


346
static inline void

347
vn_encode_VkRenderPassInputAttachmentAspectCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)

348
{

349
    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO);

350
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO });

351
    vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(enc, val->pNext);

352
    vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, val);

353
}

354


355
/* struct VkRenderPassCreateInfo chain */

356


357
static inline size_t

358
vn_sizeof_VkRenderPassCreateInfo_pnext(const void *val)

359
{

360
    const VkBaseInStructure *pnext = val;

361
    size_t size = 0;

362


363
    while (pnext) {

364
        switch ((int32_t)pnext->sType) {

365
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:

366
            size += vn_sizeof_simple_pointer(pnext);

367
            size += vn_sizeof_VkStructureType(&pnext->sType);

368
            size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);

369
            size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self((const VkRenderPassMultiviewCreateInfo *)pnext);

370
            return size;

371
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:

372
            size += vn_sizeof_simple_pointer(pnext);

373
            size += vn_sizeof_VkStructureType(&pnext->sType);

374
            size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);

375
            size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self((const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);

376
            return size;

377
        default:

378
            /* ignore unknown/unsupported struct */

379
            break;

380
        }

381
        pnext = pnext->pNext;

382
    }

383


384
    return vn_sizeof_simple_pointer(NULL);

385
}

386


387
static inline size_t

388
vn_sizeof_VkRenderPassCreateInfo_self(const VkRenderPassCreateInfo *val)

389
{

390
    size_t size = 0;

391
    /* skip val->{sType,pNext} */

392
    size += vn_sizeof_VkFlags(&val->flags);

393
    size += vn_sizeof_uint32_t(&val->attachmentCount);

394
    if (val->pAttachments) {

395
        size += vn_sizeof_array_size(val->attachmentCount);

396
        for (uint32_t i = 0; i < val->attachmentCount; i++)

397
            size += vn_sizeof_VkAttachmentDescription(&val->pAttachments[i]);

398
    } else {

399
        size += vn_sizeof_array_size(0);

400
    }

401
    size += vn_sizeof_uint32_t(&val->subpassCount);

402
    if (val->pSubpasses) {

403
        size += vn_sizeof_array_size(val->subpassCount);

404
        for (uint32_t i = 0; i < val->subpassCount; i++)

405
            size += vn_sizeof_VkSubpassDescription(&val->pSubpasses[i]);

406
    } else {

407
        size += vn_sizeof_array_size(0);

408
    }

409
    size += vn_sizeof_uint32_t(&val->dependencyCount);

410
    if (val->pDependencies) {

411
        size += vn_sizeof_array_size(val->dependencyCount);

412
        for (uint32_t i = 0; i < val->dependencyCount; i++)

413
            size += vn_sizeof_VkSubpassDependency(&val->pDependencies[i]);

414
    } else {

415
        size += vn_sizeof_array_size(0);

416
    }

417
    return size;

418
}

419


420
static inline size_t

421
vn_sizeof_VkRenderPassCreateInfo(const VkRenderPassCreateInfo *val)

422
{

423
    size_t size = 0;

424


425
    size += vn_sizeof_VkStructureType(&val->sType);

426
    size += vn_sizeof_VkRenderPassCreateInfo_pnext(val->pNext);

427
    size += vn_sizeof_VkRenderPassCreateInfo_self(val);

428


429
    return size;

430
}

431


432
static inline void

433
vn_encode_VkRenderPassCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)

434
{

435
    const VkBaseInStructure *pnext = val;

436


437
    while (pnext) {

438
        switch ((int32_t)pnext->sType) {

439
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:

440
            vn_encode_simple_pointer(enc, pnext);

441
            vn_encode_VkStructureType(enc, &pnext->sType);

442
            vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);

443
            vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, (const VkRenderPassMultiviewCreateInfo *)pnext);

444
            return;

445
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:

446
            vn_encode_simple_pointer(enc, pnext);

447
            vn_encode_VkStructureType(enc, &pnext->sType);

448
            vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);

449
            vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, (const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);

450
            return;

451
        default:

452
            /* ignore unknown/unsupported struct */

453
            break;

454
        }

455
        pnext = pnext->pNext;

456
    }

457


458
    vn_encode_simple_pointer(enc, NULL);

459
}

460


461
static inline void

462
vn_encode_VkRenderPassCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)

463
{

464
    /* skip val->{sType,pNext} */

465
    vn_encode_VkFlags(enc, &val->flags);

466
    vn_encode_uint32_t(enc, &val->attachmentCount);

467
    if (val->pAttachments) {

468
        vn_encode_array_size(enc, val->attachmentCount);

469
        for (uint32_t i = 0; i < val->attachmentCount; i++)

470
            vn_encode_VkAttachmentDescription(enc, &val->pAttachments[i]);

471
    } else {

472
        vn_encode_array_size(enc, 0);

473
    }

474
    vn_encode_uint32_t(enc, &val->subpassCount);

475
    if (val->pSubpasses) {

476
        vn_encode_array_size(enc, val->subpassCount);

477
        for (uint32_t i = 0; i < val->subpassCount; i++)

478
            vn_encode_VkSubpassDescription(enc, &val->pSubpasses[i]);

479
    } else {

480
        vn_encode_array_size(enc, 0);

481
    }

482
    vn_encode_uint32_t(enc, &val->dependencyCount);

483
    if (val->pDependencies) {

484
        vn_encode_array_size(enc, val->dependencyCount);

485
        for (uint32_t i = 0; i < val->dependencyCount; i++)

486
            vn_encode_VkSubpassDependency(enc, &val->pDependencies[i]);

487
    } else {

488
        vn_encode_array_size(enc, 0);

489
    }

490
}

491


492
static inline void

493
vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)

494
{

495
    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);

496
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO });

497
    vn_encode_VkRenderPassCreateInfo_pnext(enc, val->pNext);

498
    vn_encode_VkRenderPassCreateInfo_self(enc, val);

499
}

500


501
/* struct VkAttachmentDescriptionStencilLayout chain */

502


503
static inline size_t

504
vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void *val)

505
{

506
    /* no known/supported struct */

507
    return vn_sizeof_simple_pointer(NULL);

508
}

509


510
static inline size_t

511
vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout *val)

512
{

513
    size_t size = 0;

514
    /* skip val->{sType,pNext} */

515
    size += vn_sizeof_VkImageLayout(&val->stencilInitialLayout);

516
    size += vn_sizeof_VkImageLayout(&val->stencilFinalLayout);

517
    return size;

518
}

519


520
static inline size_t

521
vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *val)

522
{

523
    size_t size = 0;

524


525
    size += vn_sizeof_VkStructureType(&val->sType);

526
    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(val->pNext);

527
    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self(val);

528


529
    return size;

530
}

531


532
static inline void

533
vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)

534
{

535
    /* no known/supported struct */

536
    vn_encode_simple_pointer(enc, NULL);

537
}

538


539
static inline void

540
vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)

541
{

542
    /* skip val->{sType,pNext} */

543
    vn_encode_VkImageLayout(enc, &val->stencilInitialLayout);

544
    vn_encode_VkImageLayout(enc, &val->stencilFinalLayout);

545
}

546


547
static inline void

548
vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)

549
{

550
    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);

551
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT });

552
    vn_encode_VkAttachmentDescriptionStencilLayout_pnext(enc, val->pNext);

553
    vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, val);

554
}

555


556
/* struct VkAttachmentDescription2 chain */

557


558
static inline size_t

559
vn_sizeof_VkAttachmentDescription2_pnext(const void *val)

560
{

561
    const VkBaseInStructure *pnext = val;

562
    size_t size = 0;

563


564
    while (pnext) {

565
        switch ((int32_t)pnext->sType) {

566
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:

567
            size += vn_sizeof_simple_pointer(pnext);

568
            size += vn_sizeof_VkStructureType(&pnext->sType);

569
            size += vn_sizeof_VkAttachmentDescription2_pnext(pnext->pNext);

570
            size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self((const VkAttachmentDescriptionStencilLayout *)pnext);

571
            return size;

572
        default:

573
            /* ignore unknown/unsupported struct */

574
            break;

575
        }

576
        pnext = pnext->pNext;

577
    }

578


579
    return vn_sizeof_simple_pointer(NULL);

580
}

581


582
static inline size_t

583
vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 *val)

584
{

585
    size_t size = 0;

586
    /* skip val->{sType,pNext} */

587
    size += vn_sizeof_VkFlags(&val->flags);

588
    size += vn_sizeof_VkFormat(&val->format);

589
    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);

590
    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);

591
    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);

592
    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);

593
    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);

594
    size += vn_sizeof_VkImageLayout(&val->initialLayout);

595
    size += vn_sizeof_VkImageLayout(&val->finalLayout);

596
    return size;

597
}

598


599
static inline size_t

600
vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 *val)

601
{

602
    size_t size = 0;

603


604
    size += vn_sizeof_VkStructureType(&val->sType);

605
    size += vn_sizeof_VkAttachmentDescription2_pnext(val->pNext);

606
    size += vn_sizeof_VkAttachmentDescription2_self(val);

607


608
    return size;

609
}

610


611
static inline void

612
vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder *enc, const void *val)

613
{

614
    const VkBaseInStructure *pnext = val;

615


616
    while (pnext) {

617
        switch ((int32_t)pnext->sType) {

618
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:

619
            vn_encode_simple_pointer(enc, pnext);

620
            vn_encode_VkStructureType(enc, &pnext->sType);

621
            vn_encode_VkAttachmentDescription2_pnext(enc, pnext->pNext);

622
            vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, (const VkAttachmentDescriptionStencilLayout *)pnext);

623
            return;

624
        default:

625
            /* ignore unknown/unsupported struct */

626
            break;

627
        }

628
        pnext = pnext->pNext;

629
    }

630


631
    vn_encode_simple_pointer(enc, NULL);

632
}

633


634
static inline void

635
vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)

636
{

637
    /* skip val->{sType,pNext} */

638
    vn_encode_VkFlags(enc, &val->flags);

639
    vn_encode_VkFormat(enc, &val->format);

640
    vn_encode_VkSampleCountFlagBits(enc, &val->samples);

641
    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);

642
    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);

643
    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);

644
    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);

645
    vn_encode_VkImageLayout(enc, &val->initialLayout);

646
    vn_encode_VkImageLayout(enc, &val->finalLayout);

647
}

648


649
static inline void

650
vn_encode_VkAttachmentDescription2(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)

651
{

652
    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2);

653
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 });

654
    vn_encode_VkAttachmentDescription2_pnext(enc, val->pNext);

655
    vn_encode_VkAttachmentDescription2_self(enc, val);

656
}

657


658
/* struct VkAttachmentReferenceStencilLayout chain */

659


660
static inline size_t

661
vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void *val)

662
{

663
    /* no known/supported struct */

664
    return vn_sizeof_simple_pointer(NULL);

665
}

666


667
static inline size_t

668
vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout *val)

669
{

670
    size_t size = 0;

671
    /* skip val->{sType,pNext} */

672
    size += vn_sizeof_VkImageLayout(&val->stencilLayout);

673
    return size;

674
}

675


676
static inline size_t

677
vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *val)

678
{

679
    size_t size = 0;

680


681
    size += vn_sizeof_VkStructureType(&val->sType);

682
    size += vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(val->pNext);

683
    size += vn_sizeof_VkAttachmentReferenceStencilLayout_self(val);

684


685
    return size;

686
}

687


688
static inline void

689
vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)

690
{

691
    /* no known/supported struct */

692
    vn_encode_simple_pointer(enc, NULL);

693
}

694


695
static inline void

696
vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)

697
{

698
    /* skip val->{sType,pNext} */

699
    vn_encode_VkImageLayout(enc, &val->stencilLayout);

700
}

701


702
static inline void

703
vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)

704
{

705
    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT);

706
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT });

707
    vn_encode_VkAttachmentReferenceStencilLayout_pnext(enc, val->pNext);

708
    vn_encode_VkAttachmentReferenceStencilLayout_self(enc, val);

709
}

710


711
/* struct VkAttachmentReference2 chain */

712


713
static inline size_t

714
vn_sizeof_VkAttachmentReference2_pnext(const void *val)

715
{

716
    const VkBaseInStructure *pnext = val;

717
    size_t size = 0;

718


719
    while (pnext) {

720
        switch ((int32_t)pnext->sType) {

721
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:

722
            size += vn_sizeof_simple_pointer(pnext);

723
            size += vn_sizeof_VkStructureType(&pnext->sType);

724
            size += vn_sizeof_VkAttachmentReference2_pnext(pnext->pNext);

725
            size += vn_sizeof_VkAttachmentReferenceStencilLayout_self((const VkAttachmentReferenceStencilLayout *)pnext);

726
            return size;

727
        default:

728
            /* ignore unknown/unsupported struct */

729
            break;

730
        }

731
        pnext = pnext->pNext;

732
    }

733


734
    return vn_sizeof_simple_pointer(NULL);

735
}

736


737
static inline size_t

738
vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 *val)

739
{

740
    size_t size = 0;

741
    /* skip val->{sType,pNext} */

742
    size += vn_sizeof_uint32_t(&val->attachment);

743
    size += vn_sizeof_VkImageLayout(&val->layout);

744
    size += vn_sizeof_VkFlags(&val->aspectMask);

745
    return size;

746
}

747


748
static inline size_t

749
vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 *val)

750
{

751
    size_t size = 0;

752


753
    size += vn_sizeof_VkStructureType(&val->sType);

754
    size += vn_sizeof_VkAttachmentReference2_pnext(val->pNext);

755
    size += vn_sizeof_VkAttachmentReference2_self(val);

756


757
    return size;

758
}

759


760
static inline void

761
vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder *enc, const void *val)

762
{

763
    const VkBaseInStructure *pnext = val;

764


765
    while (pnext) {

766
        switch ((int32_t)pnext->sType) {

767
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:

768
            vn_encode_simple_pointer(enc, pnext);

769
            vn_encode_VkStructureType(enc, &pnext->sType);

770
            vn_encode_VkAttachmentReference2_pnext(enc, pnext->pNext);

771
            vn_encode_VkAttachmentReferenceStencilLayout_self(enc, (const VkAttachmentReferenceStencilLayout *)pnext);

772
            return;

773
        default:

774
            /* ignore unknown/unsupported struct */

775
            break;

776
        }

777
        pnext = pnext->pNext;

778
    }

779


780
    vn_encode_simple_pointer(enc, NULL);

781
}

782


783
static inline void

784
vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)

785
{

786
    /* skip val->{sType,pNext} */

787
    vn_encode_uint32_t(enc, &val->attachment);

788
    vn_encode_VkImageLayout(enc, &val->layout);

789
    vn_encode_VkFlags(enc, &val->aspectMask);

790
}

791


792
static inline void

793
vn_encode_VkAttachmentReference2(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)

794
{

795
    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2);

796
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 });

797
    vn_encode_VkAttachmentReference2_pnext(enc, val->pNext);

798
    vn_encode_VkAttachmentReference2_self(enc, val);

799
}

800


801
/* struct VkSubpassDescriptionDepthStencilResolve chain */

802


803
static inline size_t

804
vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void *val)

805
{

806
    /* no known/supported struct */

807
    return vn_sizeof_simple_pointer(NULL);

808
}

809


810
static inline size_t

811
vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve *val)

812
{

813
    size_t size = 0;

814
    /* skip val->{sType,pNext} */

815
    size += vn_sizeof_VkResolveModeFlagBits(&val->depthResolveMode);

816
    size += vn_sizeof_VkResolveModeFlagBits(&val->stencilResolveMode);

817
    size += vn_sizeof_simple_pointer(val->pDepthStencilResolveAttachment);

818
    if (val->pDepthStencilResolveAttachment)

819
        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilResolveAttachment);

820
    return size;

821
}

822


823
static inline size_t

824
vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *val)

825
{

826
    size_t size = 0;

827


828
    size += vn_sizeof_VkStructureType(&val->sType);

829
    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(val->pNext);

830
    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(val);

831


832
    return size;

833
}

834


835
static inline void

836
vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder *enc, const void *val)

837
{

838
    /* no known/supported struct */

839
    vn_encode_simple_pointer(enc, NULL);

840
}

841


842
static inline void

843
vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)

844
{

845
    /* skip val->{sType,pNext} */

846
    vn_encode_VkResolveModeFlagBits(enc, &val->depthResolveMode);

847
    vn_encode_VkResolveModeFlagBits(enc, &val->stencilResolveMode);

848
    if (vn_encode_simple_pointer(enc, val->pDepthStencilResolveAttachment))

849
        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilResolveAttachment);

850
}

851


852
static inline void

853
vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)

854
{

855
    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);

856
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE });

857
    vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(enc, val->pNext);

858
    vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, val);

859
}

860


861
/* struct VkSubpassDescription2 chain */

862


863
static inline size_t

864
vn_sizeof_VkSubpassDescription2_pnext(const void *val)

865
{

866
    const VkBaseInStructure *pnext = val;

867
    size_t size = 0;

868


869
    while (pnext) {

870
        switch ((int32_t)pnext->sType) {

871
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:

872
            size += vn_sizeof_simple_pointer(pnext);

873
            size += vn_sizeof_VkStructureType(&pnext->sType);

874
            size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext);

875
            size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self((const VkSubpassDescriptionDepthStencilResolve *)pnext);

876
            return size;

877
        default:

878
            /* ignore unknown/unsupported struct */

879
            break;

880
        }

881
        pnext = pnext->pNext;

882
    }

883


884
    return vn_sizeof_simple_pointer(NULL);

885
}

886


887
static inline size_t

888
vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 *val)

889
{

890
    size_t size = 0;

891
    /* skip val->{sType,pNext} */

892
    size += vn_sizeof_VkFlags(&val->flags);

893
    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);

894
    size += vn_sizeof_uint32_t(&val->viewMask);

895
    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);

896
    if (val->pInputAttachments) {

897
        size += vn_sizeof_array_size(val->inputAttachmentCount);

898
        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)

899
            size += vn_sizeof_VkAttachmentReference2(&val->pInputAttachments[i]);

900
    } else {

901
        size += vn_sizeof_array_size(0);

902
    }

903
    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);

904
    if (val->pColorAttachments) {

905
        size += vn_sizeof_array_size(val->colorAttachmentCount);

906
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

907
            size += vn_sizeof_VkAttachmentReference2(&val->pColorAttachments[i]);

908
    } else {

909
        size += vn_sizeof_array_size(0);

910
    }

911
    if (val->pResolveAttachments) {

912
        size += vn_sizeof_array_size(val->colorAttachmentCount);

913
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

914
            size += vn_sizeof_VkAttachmentReference2(&val->pResolveAttachments[i]);

915
    } else {

916
        size += vn_sizeof_array_size(0);

917
    }

918
    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);

919
    if (val->pDepthStencilAttachment)

920
        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilAttachment);

921
    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);

922
    if (val->pPreserveAttachments) {

923
        size += vn_sizeof_array_size(val->preserveAttachmentCount);

924
        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);

925
    } else {

926
        size += vn_sizeof_array_size(0);

927
    }

928
    return size;

929
}

930


931
static inline size_t

932
vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 *val)

933
{

934
    size_t size = 0;

935


936
    size += vn_sizeof_VkStructureType(&val->sType);

937
    size += vn_sizeof_VkSubpassDescription2_pnext(val->pNext);

938
    size += vn_sizeof_VkSubpassDescription2_self(val);

939


940
    return size;

941
}

942


943
static inline void

944
vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder *enc, const void *val)

945
{

946
    const VkBaseInStructure *pnext = val;

947


948
    while (pnext) {

949
        switch ((int32_t)pnext->sType) {

950
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:

951
            vn_encode_simple_pointer(enc, pnext);

952
            vn_encode_VkStructureType(enc, &pnext->sType);

953
            vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext);

954
            vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, (const VkSubpassDescriptionDepthStencilResolve *)pnext);

955
            return;

956
        default:

957
            /* ignore unknown/unsupported struct */

958
            break;

959
        }

960
        pnext = pnext->pNext;

961
    }

962


963
    vn_encode_simple_pointer(enc, NULL);

964
}

965


966
static inline void

967
vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)

968
{

969
    /* skip val->{sType,pNext} */

970
    vn_encode_VkFlags(enc, &val->flags);

971
    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);

972
    vn_encode_uint32_t(enc, &val->viewMask);

973
    vn_encode_uint32_t(enc, &val->inputAttachmentCount);

974
    if (val->pInputAttachments) {

975
        vn_encode_array_size(enc, val->inputAttachmentCount);

976
        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)

977
            vn_encode_VkAttachmentReference2(enc, &val->pInputAttachments[i]);

978
    } else {

979
        vn_encode_array_size(enc, 0);

980
    }

981
    vn_encode_uint32_t(enc, &val->colorAttachmentCount);

982
    if (val->pColorAttachments) {

983
        vn_encode_array_size(enc, val->colorAttachmentCount);

984
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

985
            vn_encode_VkAttachmentReference2(enc, &val->pColorAttachments[i]);

986
    } else {

987
        vn_encode_array_size(enc, 0);

988
    }

989
    if (val->pResolveAttachments) {

990
        vn_encode_array_size(enc, val->colorAttachmentCount);

991
        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)

992
            vn_encode_VkAttachmentReference2(enc, &val->pResolveAttachments[i]);

993
    } else {

994
        vn_encode_array_size(enc, 0);

995
    }

996
    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))

997
        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilAttachment);

998
    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);

999
    if (val->pPreserveAttachments) {

1000
        vn_encode_array_size(enc, val->preserveAttachmentCount);

1001
        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);

1002
    } else {

1003
        vn_encode_array_size(enc, 0);

1004
    }

1005
}

1006


1007
static inline void

1008
vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)

1009
{

1010
    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2);

1011
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 });

1012
    vn_encode_VkSubpassDescription2_pnext(enc, val->pNext);

1013
    vn_encode_VkSubpassDescription2_self(enc, val);

1014
}

1015


1016
/* struct VkSubpassDependency2 chain */

1017


1018
static inline size_t

1019
vn_sizeof_VkSubpassDependency2_pnext(const void *val)

1020
{

1021
    /* no known/supported struct */

1022
    return vn_sizeof_simple_pointer(NULL);

1023
}

1024


1025
static inline size_t

1026
vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 *val)

1027
{

1028
    size_t size = 0;

1029
    /* skip val->{sType,pNext} */

1030
    size += vn_sizeof_uint32_t(&val->srcSubpass);

1031
    size += vn_sizeof_uint32_t(&val->dstSubpass);

1032
    size += vn_sizeof_VkFlags(&val->srcStageMask);

1033
    size += vn_sizeof_VkFlags(&val->dstStageMask);

1034
    size += vn_sizeof_VkFlags(&val->srcAccessMask);

1035
    size += vn_sizeof_VkFlags(&val->dstAccessMask);

1036
    size += vn_sizeof_VkFlags(&val->dependencyFlags);

1037
    size += vn_sizeof_int32_t(&val->viewOffset);

1038
    return size;

1039
}

1040


1041
static inline size_t

1042
vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val)

1043
{

1044
    size_t size = 0;

1045


1046
    size += vn_sizeof_VkStructureType(&val->sType);

1047
    size += vn_sizeof_VkSubpassDependency2_pnext(val->pNext);

1048
    size += vn_sizeof_VkSubpassDependency2_self(val);

1049


1050
    return size;

1051
}

1052


1053
static inline void

1054
vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val)

1055
{

1056
    /* no known/supported struct */

1057
    vn_encode_simple_pointer(enc, NULL);

1058
}

1059


1060
static inline void

1061
vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)

1062
{

1063
    /* skip val->{sType,pNext} */

1064
    vn_encode_uint32_t(enc, &val->srcSubpass);

1065
    vn_encode_uint32_t(enc, &val->dstSubpass);

1066
    vn_encode_VkFlags(enc, &val->srcStageMask);

1067
    vn_encode_VkFlags(enc, &val->dstStageMask);

1068
    vn_encode_VkFlags(enc, &val->srcAccessMask);

1069
    vn_encode_VkFlags(enc, &val->dstAccessMask);

1070
    vn_encode_VkFlags(enc, &val->dependencyFlags);

1071
    vn_encode_int32_t(enc, &val->viewOffset);

1072
}

1073


1074
static inline void

1075
vn_encode_VkSubpassDependency2(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)

1076
{

1077
    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2);

1078
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 });

1079
    vn_encode_VkSubpassDependency2_pnext(enc, val->pNext);

1080
    vn_encode_VkSubpassDependency2_self(enc, val);

1081
}

1082


1083
/* struct VkRenderPassCreateInfo2 chain */

1084


1085
static inline size_t

1086
vn_sizeof_VkRenderPassCreateInfo2_pnext(const void *val)

1087
{

1088
    /* no known/supported struct */

1089
    return vn_sizeof_simple_pointer(NULL);

1090
}

1091


1092
static inline size_t

1093
vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val)

1094
{

1095
    size_t size = 0;

1096
    /* skip val->{sType,pNext} */

1097
    size += vn_sizeof_VkFlags(&val->flags);

1098
    size += vn_sizeof_uint32_t(&val->attachmentCount);

1099
    if (val->pAttachments) {

1100
        size += vn_sizeof_array_size(val->attachmentCount);

1101
        for (uint32_t i = 0; i < val->attachmentCount; i++)

1102
            size += vn_sizeof_VkAttachmentDescription2(&val->pAttachments[i]);

1103
    } else {

1104
        size += vn_sizeof_array_size(0);

1105
    }

1106
    size += vn_sizeof_uint32_t(&val->subpassCount);

1107
    if (val->pSubpasses) {

1108
        size += vn_sizeof_array_size(val->subpassCount);

1109
        for (uint32_t i = 0; i < val->subpassCount; i++)

1110
            size += vn_sizeof_VkSubpassDescription2(&val->pSubpasses[i]);

1111
    } else {

1112
        size += vn_sizeof_array_size(0);

1113
    }

1114
    size += vn_sizeof_uint32_t(&val->dependencyCount);

1115
    if (val->pDependencies) {

1116
        size += vn_sizeof_array_size(val->dependencyCount);

1117
        for (uint32_t i = 0; i < val->dependencyCount; i++)

1118
            size += vn_sizeof_VkSubpassDependency2(&val->pDependencies[i]);

1119
    } else {

1120
        size += vn_sizeof_array_size(0);

1121
    }

1122
    size += vn_sizeof_uint32_t(&val->correlatedViewMaskCount);

1123
    if (val->pCorrelatedViewMasks) {

1124
        size += vn_sizeof_array_size(val->correlatedViewMaskCount);

1125
        size += vn_sizeof_uint32_t_array(val->pCorrelatedViewMasks, val->correlatedViewMaskCount);

1126
    } else {

1127
        size += vn_sizeof_array_size(0);

1128
    }

1129
    return size;

1130
}

1131


1132
static inline size_t

1133
vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *val)

1134
{

1135
    size_t size = 0;

1136


1137
    size += vn_sizeof_VkStructureType(&val->sType);

1138
    size += vn_sizeof_VkRenderPassCreateInfo2_pnext(val->pNext);

1139
    size += vn_sizeof_VkRenderPassCreateInfo2_self(val);

1140


1141
    return size;

1142
}

1143


1144
static inline void

1145
vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder *enc, const void *val)

1146
{

1147
    /* no known/supported struct */

1148
    vn_encode_simple_pointer(enc, NULL);

1149
}

1150


1151
static inline void

1152
vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)

1153
{

1154
    /* skip val->{sType,pNext} */

1155
    vn_encode_VkFlags(enc, &val->flags);

1156
    vn_encode_uint32_t(enc, &val->attachmentCount);

1157
    if (val->pAttachments) {

1158
        vn_encode_array_size(enc, val->attachmentCount);

1159
        for (uint32_t i = 0; i < val->attachmentCount; i++)

1160
            vn_encode_VkAttachmentDescription2(enc, &val->pAttachments[i]);

1161
    } else {

1162
        vn_encode_array_size(enc, 0);

1163
    }

1164
    vn_encode_uint32_t(enc, &val->subpassCount);

1165
    if (val->pSubpasses) {

1166
        vn_encode_array_size(enc, val->subpassCount);

1167
        for (uint32_t i = 0; i < val->subpassCount; i++)

1168
            vn_encode_VkSubpassDescription2(enc, &val->pSubpasses[i]);

1169
    } else {

1170
        vn_encode_array_size(enc, 0);

1171
    }

1172
    vn_encode_uint32_t(enc, &val->dependencyCount);

1173
    if (val->pDependencies) {

1174
        vn_encode_array_size(enc, val->dependencyCount);

1175
        for (uint32_t i = 0; i < val->dependencyCount; i++)

1176
            vn_encode_VkSubpassDependency2(enc, &val->pDependencies[i]);

1177
    } else {

1178
        vn_encode_array_size(enc, 0);

1179
    }

1180
    vn_encode_uint32_t(enc, &val->correlatedViewMaskCount);

1181
    if (val->pCorrelatedViewMasks) {

1182
        vn_encode_array_size(enc, val->correlatedViewMaskCount);

1183
        vn_encode_uint32_t_array(enc, val->pCorrelatedViewMasks, val->correlatedViewMaskCount);

1184
    } else {

1185
        vn_encode_array_size(enc, 0);

1186
    }

1187
}

1188


1189
static inline void

1190
vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)

1191
{

1192
    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);

1193
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 });

1194
    vn_encode_VkRenderPassCreateInfo2_pnext(enc, val->pNext);

1195
    vn_encode_VkRenderPassCreateInfo2_self(enc, val);

1196
}

1197


1198
static inline size_t vn_sizeof_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1199
{

1200
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;

1201
    const VkFlags cmd_flags = 0;

1202
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);

1203


1204
    cmd_size += vn_sizeof_VkDevice(&device);

1205
    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);

1206
    if (pCreateInfo)

1207
        cmd_size += vn_sizeof_VkRenderPassCreateInfo(pCreateInfo);

1208
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

1209
    if (pAllocator)

1210
        assert(false);

1211
    cmd_size += vn_sizeof_simple_pointer(pRenderPass);

1212
    if (pRenderPass)

1213
        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);

1214


1215
    return cmd_size;

1216
}

1217


1218
static inline void vn_encode_vkCreateRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1219
{

1220
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;

1221


1222
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

1223
    vn_encode_VkFlags(enc, &cmd_flags);

1224


1225
    vn_encode_VkDevice(enc, &device);

1226
    if (vn_encode_simple_pointer(enc, pCreateInfo))

1227
        vn_encode_VkRenderPassCreateInfo(enc, pCreateInfo);

1228
    if (vn_encode_simple_pointer(enc, pAllocator))

1229
        assert(false);

1230
    if (vn_encode_simple_pointer(enc, pRenderPass))

1231
        vn_encode_VkRenderPass(enc, pRenderPass);

1232
}

1233


1234
static inline size_t vn_sizeof_vkCreateRenderPass_reply(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1235
{

1236
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;

1237
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

1238


1239
    VkResult ret;

1240
    cmd_size += vn_sizeof_VkResult(&ret);

1241
    /* skip device */

1242
    /* skip pCreateInfo */

1243
    /* skip pAllocator */

1244
    cmd_size += vn_sizeof_simple_pointer(pRenderPass);

1245
    if (pRenderPass)

1246
        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);

1247


1248
    return cmd_size;

1249
}

1250


1251
static inline VkResult vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1252
{

1253
    VkCommandTypeEXT command_type;

1254
    vn_decode_VkCommandTypeEXT(dec, &command_type);

1255
    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass_EXT);

1256


1257
    VkResult ret;

1258
    vn_decode_VkResult(dec, &ret);

1259
    /* skip device */

1260
    /* skip pCreateInfo */

1261
    /* skip pAllocator */

1262
    if (vn_decode_simple_pointer(dec)) {

1263
        vn_decode_VkRenderPass(dec, pRenderPass);

1264
    } else {

1265
        pRenderPass = NULL;

1266
    }

1267


1268
    return ret;

1269
}

1270


1271
static inline size_t vn_sizeof_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)

1272
{

1273
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;

1274
    const VkFlags cmd_flags = 0;

1275
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);

1276


1277
    cmd_size += vn_sizeof_VkDevice(&device);

1278
    cmd_size += vn_sizeof_VkRenderPass(&renderPass);

1279
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

1280
    if (pAllocator)

1281
        assert(false);

1282


1283
    return cmd_size;

1284
}

1285


1286
static inline void vn_encode_vkDestroyRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)

1287
{

1288
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;

1289


1290
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

1291
    vn_encode_VkFlags(enc, &cmd_flags);

1292


1293
    vn_encode_VkDevice(enc, &device);

1294
    vn_encode_VkRenderPass(enc, &renderPass);

1295
    if (vn_encode_simple_pointer(enc, pAllocator))

1296
        assert(false);

1297
}

1298


1299
static inline size_t vn_sizeof_vkDestroyRenderPass_reply(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)

1300
{

1301
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;

1302
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

1303


1304
    /* skip device */

1305
    /* skip renderPass */

1306
    /* skip pAllocator */

1307


1308
    return cmd_size;

1309
}

1310


1311
static inline void vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)

1312
{

1313
    VkCommandTypeEXT command_type;

1314
    vn_decode_VkCommandTypeEXT(dec, &command_type);

1315
    assert(command_type == VK_COMMAND_TYPE_vkDestroyRenderPass_EXT);

1316


1317
    /* skip device */

1318
    /* skip renderPass */

1319
    /* skip pAllocator */

1320
}

1321


1322
static inline size_t vn_sizeof_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)

1323
{

1324
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;

1325
    const VkFlags cmd_flags = 0;

1326
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);

1327


1328
    cmd_size += vn_sizeof_VkDevice(&device);

1329
    cmd_size += vn_sizeof_VkRenderPass(&renderPass);

1330
    cmd_size += vn_sizeof_simple_pointer(pGranularity);

1331
    if (pGranularity)

1332
        cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);

1333


1334
    return cmd_size;

1335
}

1336


1337
static inline void vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)

1338
{

1339
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;

1340


1341
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

1342
    vn_encode_VkFlags(enc, &cmd_flags);

1343


1344
    vn_encode_VkDevice(enc, &device);

1345
    vn_encode_VkRenderPass(enc, &renderPass);

1346
    if (vn_encode_simple_pointer(enc, pGranularity))

1347
        vn_encode_VkExtent2D_partial(enc, pGranularity);

1348
}

1349


1350
static inline size_t vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)

1351
{

1352
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;

1353
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

1354


1355
    /* skip device */

1356
    /* skip renderPass */

1357
    cmd_size += vn_sizeof_simple_pointer(pGranularity);

1358
    if (pGranularity)

1359
        cmd_size += vn_sizeof_VkExtent2D(pGranularity);

1360


1361
    return cmd_size;

1362
}

1363


1364
static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)

1365
{

1366
    VkCommandTypeEXT command_type;

1367
    vn_decode_VkCommandTypeEXT(dec, &command_type);

1368
    assert(command_type == VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT);

1369


1370
    /* skip device */

1371
    /* skip renderPass */

1372
    if (vn_decode_simple_pointer(dec)) {

1373
        vn_decode_VkExtent2D(dec, pGranularity);

1374
    } else {

1375
        pGranularity = NULL;

1376
    }

1377
}

1378


1379
static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1380
{

1381
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;

1382
    const VkFlags cmd_flags = 0;

1383
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);

1384


1385
    cmd_size += vn_sizeof_VkDevice(&device);

1386
    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);

1387
    if (pCreateInfo)

1388
        cmd_size += vn_sizeof_VkRenderPassCreateInfo2(pCreateInfo);

1389
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

1390
    if (pAllocator)

1391
        assert(false);

1392
    cmd_size += vn_sizeof_simple_pointer(pRenderPass);

1393
    if (pRenderPass)

1394
        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);

1395


1396
    return cmd_size;

1397
}

1398


1399
static inline void vn_encode_vkCreateRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1400
{

1401
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;

1402


1403
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

1404
    vn_encode_VkFlags(enc, &cmd_flags);

1405


1406
    vn_encode_VkDevice(enc, &device);

1407
    if (vn_encode_simple_pointer(enc, pCreateInfo))

1408
        vn_encode_VkRenderPassCreateInfo2(enc, pCreateInfo);

1409
    if (vn_encode_simple_pointer(enc, pAllocator))

1410
        assert(false);

1411
    if (vn_encode_simple_pointer(enc, pRenderPass))

1412
        vn_encode_VkRenderPass(enc, pRenderPass);

1413
}

1414


1415
static inline size_t vn_sizeof_vkCreateRenderPass2_reply(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1416
{

1417
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;

1418
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

1419


1420
    VkResult ret;

1421
    cmd_size += vn_sizeof_VkResult(&ret);

1422
    /* skip device */

1423
    /* skip pCreateInfo */

1424
    /* skip pAllocator */

1425
    cmd_size += vn_sizeof_simple_pointer(pRenderPass);

1426
    if (pRenderPass)

1427
        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);

1428


1429
    return cmd_size;

1430
}

1431


1432
static inline VkResult vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1433
{

1434
    VkCommandTypeEXT command_type;

1435
    vn_decode_VkCommandTypeEXT(dec, &command_type);

1436
    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass2_EXT);

1437


1438
    VkResult ret;

1439
    vn_decode_VkResult(dec, &ret);

1440
    /* skip device */

1441
    /* skip pCreateInfo */

1442
    /* skip pAllocator */

1443
    if (vn_decode_simple_pointer(dec)) {

1444
        vn_decode_VkRenderPass(dec, pRenderPass);

1445
    } else {

1446
        pRenderPass = NULL;

1447
    }

1448


1449
    return ret;

1450
}

1451


1452
static inline void vn_submit_vkCreateRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)

1453
{

1454
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

1455
    void *cmd_data = local_cmd_data;

1456
    size_t cmd_size = vn_sizeof_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);

1457
    if (cmd_size > sizeof(local_cmd_data)) {

1458
        cmd_data = malloc(cmd_size);

1459
        if (!cmd_data)

1460
            cmd_size = 0;

1461
    }

1462
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;

1463


1464
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);

1465
    if (cmd_size) {

1466
        vn_encode_vkCreateRenderPass(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);

1467
        vn_instance_submit_command(vn_instance, submit);

1468
        if (cmd_data != local_cmd_data)

1469
            free(cmd_data);

1470
    }

1471
}

1472


1473
static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)

1474
{

1475
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

1476
    void *cmd_data = local_cmd_data;

1477
    size_t cmd_size = vn_sizeof_vkDestroyRenderPass(device, renderPass, pAllocator);

1478
    if (cmd_size > sizeof(local_cmd_data)) {

1479
        cmd_data = malloc(cmd_size);

1480
        if (!cmd_data)

1481
            cmd_size = 0;

1482
    }

1483
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;

1484


1485
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);

1486
    if (cmd_size) {

1487
        vn_encode_vkDestroyRenderPass(enc, cmd_flags, device, renderPass, pAllocator);

1488
        vn_instance_submit_command(vn_instance, submit);

1489
        if (cmd_data != local_cmd_data)

1490
            free(cmd_data);

1491
    }

1492
}

1493


1494
static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_instance_submit_command *submit)

1495
{

1496
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

1497
    void *cmd_data = local_cmd_data;

1498
    size_t cmd_size = vn_sizeof_vkGetRenderAreaGranularity(device, renderPass, pGranularity);

1499
    if (cmd_size > sizeof(local_cmd_data)) {

1500
        cmd_data = malloc(cmd_size);

1501
        if (!cmd_data)

1502
            cmd_size = 0;

1503
    }

1504
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;

1505


1506
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);

1507
    if (cmd_size) {

1508
        vn_encode_vkGetRenderAreaGranularity(enc, cmd_flags, device, renderPass, pGranularity);

1509
        vn_instance_submit_command(vn_instance, submit);

1510
        if (cmd_data != local_cmd_data)

1511
            free(cmd_data);

1512
    }

1513
}

1514


1515
static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)

1516
{

1517
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

1518
    void *cmd_data = local_cmd_data;

1519
    size_t cmd_size = vn_sizeof_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);

1520
    if (cmd_size > sizeof(local_cmd_data)) {

1521
        cmd_data = malloc(cmd_size);

1522
        if (!cmd_data)

1523
            cmd_size = 0;

1524
    }

1525
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;

1526


1527
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);

1528
    if (cmd_size) {

1529
        vn_encode_vkCreateRenderPass2(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);

1530
        vn_instance_submit_command(vn_instance, submit);

1531
        if (cmd_data != local_cmd_data)

1532
            free(cmd_data);

1533
    }

1534
}

1535


1536
static inline VkResult vn_call_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1537
{

1538
    struct vn_instance_submit_command submit;

1539
    vn_submit_vkCreateRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);

1540
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);

1541
    if (dec) {

1542
        const VkResult ret = vn_decode_vkCreateRenderPass_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);

1543
        vn_instance_free_command_reply(vn_instance, &submit);

1544
        return ret;

1545
    } else {

1546
        return VK_ERROR_OUT_OF_HOST_MEMORY;

1547
    }

1548
}

1549


1550
static inline void vn_async_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1551
{

1552
    struct vn_instance_submit_command submit;

1553
    vn_submit_vkCreateRenderPass(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);

1554
}

1555


1556
static inline void vn_call_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)

1557
{

1558
    struct vn_instance_submit_command submit;

1559
    vn_submit_vkDestroyRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit);

1560
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);

1561
    if (dec) {

1562
        vn_decode_vkDestroyRenderPass_reply(dec, device, renderPass, pAllocator);

1563
        vn_instance_free_command_reply(vn_instance, &submit);

1564
    }

1565
}

1566


1567
static inline void vn_async_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)

1568
{

1569
    struct vn_instance_submit_command submit;

1570
    vn_submit_vkDestroyRenderPass(vn_instance, 0, device, renderPass, pAllocator, &submit);

1571
}

1572


1573
static inline void vn_call_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)

1574
{

1575
    struct vn_instance_submit_command submit;

1576
    vn_submit_vkGetRenderAreaGranularity(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit);

1577
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);

1578
    if (dec) {

1579
        vn_decode_vkGetRenderAreaGranularity_reply(dec, device, renderPass, pGranularity);

1580
        vn_instance_free_command_reply(vn_instance, &submit);

1581
    }

1582
}

1583


1584
static inline void vn_async_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)

1585
{

1586
    struct vn_instance_submit_command submit;

1587
    vn_submit_vkGetRenderAreaGranularity(vn_instance, 0, device, renderPass, pGranularity, &submit);

1588
}

1589


1590
static inline VkResult vn_call_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1591
{

1592
    struct vn_instance_submit_command submit;

1593
    vn_submit_vkCreateRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);

1594
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);

1595
    if (dec) {

1596
        const VkResult ret = vn_decode_vkCreateRenderPass2_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);

1597
        vn_instance_free_command_reply(vn_instance, &submit);

1598
        return ret;

1599
    } else {

1600
        return VK_ERROR_OUT_OF_HOST_MEMORY;

1601
    }

1602
}

1603


1604
static inline void vn_async_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)

1605
{

1606
    struct vn_instance_submit_command submit;

1607
    vn_submit_vkCreateRenderPass2(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);

1608
}

1609


1610
#endif /* VN_PROTOCOL_DRIVER_RENDER_PASS_H */

1611


1612