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_DEVICE_MEMORY_H
9 #define VN_PROTOCOL_DRIVER_DEVICE_MEMORY_H
10
11 #include "vn_ring.h"
12 #include "vn_protocol_driver_structs.h"
13
14 /*
15 * These structs/unions/commands are not included
16 *
17 * VkImportMemoryFdInfoKHR
18 * vkMapMemory
19 * vkGetMemoryFdKHR
20 * vkGetMemoryFdPropertiesKHR
21 */
22
23 /* struct VkExportMemoryAllocateInfo chain */
24
25 static inline size_t
vn_sizeof_VkExportMemoryAllocateInfo_pnext(const void * val)26 vn_sizeof_VkExportMemoryAllocateInfo_pnext(const void *val)
27 {
28 /* no known/supported struct */
29 return vn_sizeof_simple_pointer(NULL);
30 }
31
32 static inline size_t
vn_sizeof_VkExportMemoryAllocateInfo_self(const VkExportMemoryAllocateInfo * val)33 vn_sizeof_VkExportMemoryAllocateInfo_self(const VkExportMemoryAllocateInfo *val)
34 {
35 size_t size = 0;
36 /* skip val->{sType,pNext} */
37 size += vn_sizeof_VkFlags(&val->handleTypes);
38 return size;
39 }
40
41 static inline size_t
vn_sizeof_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo * val)42 vn_sizeof_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo *val)
43 {
44 size_t size = 0;
45
46 size += vn_sizeof_VkStructureType(&val->sType);
47 size += vn_sizeof_VkExportMemoryAllocateInfo_pnext(val->pNext);
48 size += vn_sizeof_VkExportMemoryAllocateInfo_self(val);
49
50 return size;
51 }
52
53 static inline void
vn_encode_VkExportMemoryAllocateInfo_pnext(struct vn_cs_encoder * enc,const void * val)54 vn_encode_VkExportMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
55 {
56 /* no known/supported struct */
57 vn_encode_simple_pointer(enc, NULL);
58 }
59
60 static inline void
vn_encode_VkExportMemoryAllocateInfo_self(struct vn_cs_encoder * enc,const VkExportMemoryAllocateInfo * val)61 vn_encode_VkExportMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val)
62 {
63 /* skip val->{sType,pNext} */
64 vn_encode_VkFlags(enc, &val->handleTypes);
65 }
66
67 static inline void
vn_encode_VkExportMemoryAllocateInfo(struct vn_cs_encoder * enc,const VkExportMemoryAllocateInfo * val)68 vn_encode_VkExportMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val)
69 {
70 assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
71 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO });
72 vn_encode_VkExportMemoryAllocateInfo_pnext(enc, val->pNext);
73 vn_encode_VkExportMemoryAllocateInfo_self(enc, val);
74 }
75
76 /* struct VkMemoryAllocateFlagsInfo chain */
77
78 static inline size_t
vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(const void * val)79 vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(const void *val)
80 {
81 /* no known/supported struct */
82 return vn_sizeof_simple_pointer(NULL);
83 }
84
85 static inline size_t
vn_sizeof_VkMemoryAllocateFlagsInfo_self(const VkMemoryAllocateFlagsInfo * val)86 vn_sizeof_VkMemoryAllocateFlagsInfo_self(const VkMemoryAllocateFlagsInfo *val)
87 {
88 size_t size = 0;
89 /* skip val->{sType,pNext} */
90 size += vn_sizeof_VkFlags(&val->flags);
91 size += vn_sizeof_uint32_t(&val->deviceMask);
92 return size;
93 }
94
95 static inline size_t
vn_sizeof_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo * val)96 vn_sizeof_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo *val)
97 {
98 size_t size = 0;
99
100 size += vn_sizeof_VkStructureType(&val->sType);
101 size += vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(val->pNext);
102 size += vn_sizeof_VkMemoryAllocateFlagsInfo_self(val);
103
104 return size;
105 }
106
107 static inline void
vn_encode_VkMemoryAllocateFlagsInfo_pnext(struct vn_cs_encoder * enc,const void * val)108 vn_encode_VkMemoryAllocateFlagsInfo_pnext(struct vn_cs_encoder *enc, const void *val)
109 {
110 /* no known/supported struct */
111 vn_encode_simple_pointer(enc, NULL);
112 }
113
114 static inline void
vn_encode_VkMemoryAllocateFlagsInfo_self(struct vn_cs_encoder * enc,const VkMemoryAllocateFlagsInfo * val)115 vn_encode_VkMemoryAllocateFlagsInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val)
116 {
117 /* skip val->{sType,pNext} */
118 vn_encode_VkFlags(enc, &val->flags);
119 vn_encode_uint32_t(enc, &val->deviceMask);
120 }
121
122 static inline void
vn_encode_VkMemoryAllocateFlagsInfo(struct vn_cs_encoder * enc,const VkMemoryAllocateFlagsInfo * val)123 vn_encode_VkMemoryAllocateFlagsInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val)
124 {
125 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO);
126 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO });
127 vn_encode_VkMemoryAllocateFlagsInfo_pnext(enc, val->pNext);
128 vn_encode_VkMemoryAllocateFlagsInfo_self(enc, val);
129 }
130
131 /* struct VkMemoryDedicatedAllocateInfo chain */
132
133 static inline size_t
vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(const void * val)134 vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(const void *val)
135 {
136 /* no known/supported struct */
137 return vn_sizeof_simple_pointer(NULL);
138 }
139
140 static inline size_t
vn_sizeof_VkMemoryDedicatedAllocateInfo_self(const VkMemoryDedicatedAllocateInfo * val)141 vn_sizeof_VkMemoryDedicatedAllocateInfo_self(const VkMemoryDedicatedAllocateInfo *val)
142 {
143 size_t size = 0;
144 /* skip val->{sType,pNext} */
145 size += vn_sizeof_VkImage(&val->image);
146 size += vn_sizeof_VkBuffer(&val->buffer);
147 return size;
148 }
149
150 static inline size_t
vn_sizeof_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo * val)151 vn_sizeof_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo *val)
152 {
153 size_t size = 0;
154
155 size += vn_sizeof_VkStructureType(&val->sType);
156 size += vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(val->pNext);
157 size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self(val);
158
159 return size;
160 }
161
162 static inline void
vn_encode_VkMemoryDedicatedAllocateInfo_pnext(struct vn_cs_encoder * enc,const void * val)163 vn_encode_VkMemoryDedicatedAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
164 {
165 /* no known/supported struct */
166 vn_encode_simple_pointer(enc, NULL);
167 }
168
169 static inline void
vn_encode_VkMemoryDedicatedAllocateInfo_self(struct vn_cs_encoder * enc,const VkMemoryDedicatedAllocateInfo * val)170 vn_encode_VkMemoryDedicatedAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val)
171 {
172 /* skip val->{sType,pNext} */
173 vn_encode_VkImage(enc, &val->image);
174 vn_encode_VkBuffer(enc, &val->buffer);
175 }
176
177 static inline void
vn_encode_VkMemoryDedicatedAllocateInfo(struct vn_cs_encoder * enc,const VkMemoryDedicatedAllocateInfo * val)178 vn_encode_VkMemoryDedicatedAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val)
179 {
180 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
181 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO });
182 vn_encode_VkMemoryDedicatedAllocateInfo_pnext(enc, val->pNext);
183 vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, val);
184 }
185
186 /* struct VkMemoryOpaqueCaptureAddressAllocateInfo chain */
187
188 static inline size_t
vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(const void * val)189 vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(const void *val)
190 {
191 /* no known/supported struct */
192 return vn_sizeof_simple_pointer(NULL);
193 }
194
195 static inline size_t
vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(const VkMemoryOpaqueCaptureAddressAllocateInfo * val)196 vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
197 {
198 size_t size = 0;
199 /* skip val->{sType,pNext} */
200 size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress);
201 return size;
202 }
203
204 static inline size_t
vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo * val)205 vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
206 {
207 size_t size = 0;
208
209 size += vn_sizeof_VkStructureType(&val->sType);
210 size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(val->pNext);
211 size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(val);
212
213 return size;
214 }
215
216 static inline void
vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(struct vn_cs_encoder * enc,const void * val)217 vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
218 {
219 /* no known/supported struct */
220 vn_encode_simple_pointer(enc, NULL);
221 }
222
223 static inline void
vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(struct vn_cs_encoder * enc,const VkMemoryOpaqueCaptureAddressAllocateInfo * val)224 vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
225 {
226 /* skip val->{sType,pNext} */
227 vn_encode_uint64_t(enc, &val->opaqueCaptureAddress);
228 }
229
230 static inline void
vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo(struct vn_cs_encoder * enc,const VkMemoryOpaqueCaptureAddressAllocateInfo * val)231 vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val)
232 {
233 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
234 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO });
235 vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(enc, val->pNext);
236 vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, val);
237 }
238
239 /* struct VkImportMemoryResourceInfoMESA chain */
240
241 static inline size_t
vn_sizeof_VkImportMemoryResourceInfoMESA_pnext(const void * val)242 vn_sizeof_VkImportMemoryResourceInfoMESA_pnext(const void *val)
243 {
244 /* no known/supported struct */
245 return vn_sizeof_simple_pointer(NULL);
246 }
247
248 static inline size_t
vn_sizeof_VkImportMemoryResourceInfoMESA_self(const VkImportMemoryResourceInfoMESA * val)249 vn_sizeof_VkImportMemoryResourceInfoMESA_self(const VkImportMemoryResourceInfoMESA *val)
250 {
251 size_t size = 0;
252 /* skip val->{sType,pNext} */
253 size += vn_sizeof_uint32_t(&val->resourceId);
254 return size;
255 }
256
257 static inline size_t
vn_sizeof_VkImportMemoryResourceInfoMESA(const VkImportMemoryResourceInfoMESA * val)258 vn_sizeof_VkImportMemoryResourceInfoMESA(const VkImportMemoryResourceInfoMESA *val)
259 {
260 size_t size = 0;
261
262 size += vn_sizeof_VkStructureType(&val->sType);
263 size += vn_sizeof_VkImportMemoryResourceInfoMESA_pnext(val->pNext);
264 size += vn_sizeof_VkImportMemoryResourceInfoMESA_self(val);
265
266 return size;
267 }
268
269 static inline void
vn_encode_VkImportMemoryResourceInfoMESA_pnext(struct vn_cs_encoder * enc,const void * val)270 vn_encode_VkImportMemoryResourceInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val)
271 {
272 /* no known/supported struct */
273 vn_encode_simple_pointer(enc, NULL);
274 }
275
276 static inline void
vn_encode_VkImportMemoryResourceInfoMESA_self(struct vn_cs_encoder * enc,const VkImportMemoryResourceInfoMESA * val)277 vn_encode_VkImportMemoryResourceInfoMESA_self(struct vn_cs_encoder *enc, const VkImportMemoryResourceInfoMESA *val)
278 {
279 /* skip val->{sType,pNext} */
280 vn_encode_uint32_t(enc, &val->resourceId);
281 }
282
283 static inline void
vn_encode_VkImportMemoryResourceInfoMESA(struct vn_cs_encoder * enc,const VkImportMemoryResourceInfoMESA * val)284 vn_encode_VkImportMemoryResourceInfoMESA(struct vn_cs_encoder *enc, const VkImportMemoryResourceInfoMESA *val)
285 {
286 assert(val->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_RESOURCE_INFO_MESA);
287 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMPORT_MEMORY_RESOURCE_INFO_MESA });
288 vn_encode_VkImportMemoryResourceInfoMESA_pnext(enc, val->pNext);
289 vn_encode_VkImportMemoryResourceInfoMESA_self(enc, val);
290 }
291
292 /* struct VkMemoryAllocateInfo chain */
293
294 static inline size_t
vn_sizeof_VkMemoryAllocateInfo_pnext(const void * val)295 vn_sizeof_VkMemoryAllocateInfo_pnext(const void *val)
296 {
297 const VkBaseInStructure *pnext = val;
298 size_t size = 0;
299
300 while (pnext) {
301 switch ((int32_t)pnext->sType) {
302 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
303 size += vn_sizeof_simple_pointer(pnext);
304 size += vn_sizeof_VkStructureType(&pnext->sType);
305 size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
306 size += vn_sizeof_VkExportMemoryAllocateInfo_self((const VkExportMemoryAllocateInfo *)pnext);
307 return size;
308 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
309 size += vn_sizeof_simple_pointer(pnext);
310 size += vn_sizeof_VkStructureType(&pnext->sType);
311 size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
312 size += vn_sizeof_VkMemoryAllocateFlagsInfo_self((const VkMemoryAllocateFlagsInfo *)pnext);
313 return size;
314 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
315 size += vn_sizeof_simple_pointer(pnext);
316 size += vn_sizeof_VkStructureType(&pnext->sType);
317 size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
318 size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self((const VkMemoryDedicatedAllocateInfo *)pnext);
319 return size;
320 case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
321 size += vn_sizeof_simple_pointer(pnext);
322 size += vn_sizeof_VkStructureType(&pnext->sType);
323 size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
324 size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self((const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext);
325 return size;
326 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_RESOURCE_INFO_MESA:
327 size += vn_sizeof_simple_pointer(pnext);
328 size += vn_sizeof_VkStructureType(&pnext->sType);
329 size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext);
330 size += vn_sizeof_VkImportMemoryResourceInfoMESA_self((const VkImportMemoryResourceInfoMESA *)pnext);
331 return size;
332 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
333 default:
334 /* ignore unknown/unsupported struct */
335 break;
336 }
337 pnext = pnext->pNext;
338 }
339
340 return vn_sizeof_simple_pointer(NULL);
341 }
342
343 static inline size_t
vn_sizeof_VkMemoryAllocateInfo_self(const VkMemoryAllocateInfo * val)344 vn_sizeof_VkMemoryAllocateInfo_self(const VkMemoryAllocateInfo *val)
345 {
346 size_t size = 0;
347 /* skip val->{sType,pNext} */
348 size += vn_sizeof_VkDeviceSize(&val->allocationSize);
349 size += vn_sizeof_uint32_t(&val->memoryTypeIndex);
350 return size;
351 }
352
353 static inline size_t
vn_sizeof_VkMemoryAllocateInfo(const VkMemoryAllocateInfo * val)354 vn_sizeof_VkMemoryAllocateInfo(const VkMemoryAllocateInfo *val)
355 {
356 size_t size = 0;
357
358 size += vn_sizeof_VkStructureType(&val->sType);
359 size += vn_sizeof_VkMemoryAllocateInfo_pnext(val->pNext);
360 size += vn_sizeof_VkMemoryAllocateInfo_self(val);
361
362 return size;
363 }
364
365 static inline void
vn_encode_VkMemoryAllocateInfo_pnext(struct vn_cs_encoder * enc,const void * val)366 vn_encode_VkMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
367 {
368 const VkBaseInStructure *pnext = val;
369
370 while (pnext) {
371 switch ((int32_t)pnext->sType) {
372 case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
373 vn_encode_simple_pointer(enc, pnext);
374 vn_encode_VkStructureType(enc, &pnext->sType);
375 vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
376 vn_encode_VkExportMemoryAllocateInfo_self(enc, (const VkExportMemoryAllocateInfo *)pnext);
377 return;
378 case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
379 vn_encode_simple_pointer(enc, pnext);
380 vn_encode_VkStructureType(enc, &pnext->sType);
381 vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
382 vn_encode_VkMemoryAllocateFlagsInfo_self(enc, (const VkMemoryAllocateFlagsInfo *)pnext);
383 return;
384 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
385 vn_encode_simple_pointer(enc, pnext);
386 vn_encode_VkStructureType(enc, &pnext->sType);
387 vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
388 vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, (const VkMemoryDedicatedAllocateInfo *)pnext);
389 return;
390 case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
391 vn_encode_simple_pointer(enc, pnext);
392 vn_encode_VkStructureType(enc, &pnext->sType);
393 vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
394 vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, (const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext);
395 return;
396 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_RESOURCE_INFO_MESA:
397 vn_encode_simple_pointer(enc, pnext);
398 vn_encode_VkStructureType(enc, &pnext->sType);
399 vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext);
400 vn_encode_VkImportMemoryResourceInfoMESA_self(enc, (const VkImportMemoryResourceInfoMESA *)pnext);
401 return;
402 case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
403 default:
404 /* ignore unknown/unsupported struct */
405 break;
406 }
407 pnext = pnext->pNext;
408 }
409
410 vn_encode_simple_pointer(enc, NULL);
411 }
412
413 static inline void
vn_encode_VkMemoryAllocateInfo_self(struct vn_cs_encoder * enc,const VkMemoryAllocateInfo * val)414 vn_encode_VkMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val)
415 {
416 /* skip val->{sType,pNext} */
417 vn_encode_VkDeviceSize(enc, &val->allocationSize);
418 vn_encode_uint32_t(enc, &val->memoryTypeIndex);
419 }
420
421 static inline void
vn_encode_VkMemoryAllocateInfo(struct vn_cs_encoder * enc,const VkMemoryAllocateInfo * val)422 vn_encode_VkMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val)
423 {
424 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
425 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO });
426 vn_encode_VkMemoryAllocateInfo_pnext(enc, val->pNext);
427 vn_encode_VkMemoryAllocateInfo_self(enc, val);
428 }
429
430 /* struct VkMappedMemoryRange chain */
431
432 static inline size_t
vn_sizeof_VkMappedMemoryRange_pnext(const void * val)433 vn_sizeof_VkMappedMemoryRange_pnext(const void *val)
434 {
435 /* no known/supported struct */
436 return vn_sizeof_simple_pointer(NULL);
437 }
438
439 static inline size_t
vn_sizeof_VkMappedMemoryRange_self(const VkMappedMemoryRange * val)440 vn_sizeof_VkMappedMemoryRange_self(const VkMappedMemoryRange *val)
441 {
442 size_t size = 0;
443 /* skip val->{sType,pNext} */
444 size += vn_sizeof_VkDeviceMemory(&val->memory);
445 size += vn_sizeof_VkDeviceSize(&val->offset);
446 size += vn_sizeof_VkDeviceSize(&val->size);
447 return size;
448 }
449
450 static inline size_t
vn_sizeof_VkMappedMemoryRange(const VkMappedMemoryRange * val)451 vn_sizeof_VkMappedMemoryRange(const VkMappedMemoryRange *val)
452 {
453 size_t size = 0;
454
455 size += vn_sizeof_VkStructureType(&val->sType);
456 size += vn_sizeof_VkMappedMemoryRange_pnext(val->pNext);
457 size += vn_sizeof_VkMappedMemoryRange_self(val);
458
459 return size;
460 }
461
462 static inline void
vn_encode_VkMappedMemoryRange_pnext(struct vn_cs_encoder * enc,const void * val)463 vn_encode_VkMappedMemoryRange_pnext(struct vn_cs_encoder *enc, const void *val)
464 {
465 /* no known/supported struct */
466 vn_encode_simple_pointer(enc, NULL);
467 }
468
469 static inline void
vn_encode_VkMappedMemoryRange_self(struct vn_cs_encoder * enc,const VkMappedMemoryRange * val)470 vn_encode_VkMappedMemoryRange_self(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val)
471 {
472 /* skip val->{sType,pNext} */
473 vn_encode_VkDeviceMemory(enc, &val->memory);
474 vn_encode_VkDeviceSize(enc, &val->offset);
475 vn_encode_VkDeviceSize(enc, &val->size);
476 }
477
478 static inline void
vn_encode_VkMappedMemoryRange(struct vn_cs_encoder * enc,const VkMappedMemoryRange * val)479 vn_encode_VkMappedMemoryRange(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val)
480 {
481 assert(val->sType == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE);
482 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE });
483 vn_encode_VkMappedMemoryRange_pnext(enc, val->pNext);
484 vn_encode_VkMappedMemoryRange_self(enc, val);
485 }
486
487 /* struct VkDeviceMemoryOpaqueCaptureAddressInfo chain */
488
489 static inline size_t
vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(const void * val)490 vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(const void *val)
491 {
492 /* no known/supported struct */
493 return vn_sizeof_simple_pointer(NULL);
494 }
495
496 static inline size_t
vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(const VkDeviceMemoryOpaqueCaptureAddressInfo * val)497 vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
498 {
499 size_t size = 0;
500 /* skip val->{sType,pNext} */
501 size += vn_sizeof_VkDeviceMemory(&val->memory);
502 return size;
503 }
504
505 static inline size_t
vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo * val)506 vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
507 {
508 size_t size = 0;
509
510 size += vn_sizeof_VkStructureType(&val->sType);
511 size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(val->pNext);
512 size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(val);
513
514 return size;
515 }
516
517 static inline void
vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_encoder * enc,const void * val)518 vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val)
519 {
520 /* no known/supported struct */
521 vn_encode_simple_pointer(enc, NULL);
522 }
523
524 static inline void
vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_encoder * enc,const VkDeviceMemoryOpaqueCaptureAddressInfo * val)525 vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
526 {
527 /* skip val->{sType,pNext} */
528 vn_encode_VkDeviceMemory(enc, &val->memory);
529 }
530
531 static inline void
vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_encoder * enc,const VkDeviceMemoryOpaqueCaptureAddressInfo * val)532 vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val)
533 {
534 assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO);
535 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO });
536 vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(enc, val->pNext);
537 vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(enc, val);
538 }
539
540 /* struct VkMemoryResourceAllocationSizePropertiesMESA chain */
541
542 static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext(const void * val)543 vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext(const void *val)
544 {
545 /* no known/supported struct */
546 return vn_sizeof_simple_pointer(NULL);
547 }
548
549 static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self(const VkMemoryResourceAllocationSizePropertiesMESA * val)550 vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self(const VkMemoryResourceAllocationSizePropertiesMESA *val)
551 {
552 size_t size = 0;
553 /* skip val->{sType,pNext} */
554 size += vn_sizeof_uint64_t(&val->allocationSize);
555 return size;
556 }
557
558 static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA(const VkMemoryResourceAllocationSizePropertiesMESA * val)559 vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA(const VkMemoryResourceAllocationSizePropertiesMESA *val)
560 {
561 size_t size = 0;
562
563 size += vn_sizeof_VkStructureType(&val->sType);
564 size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext(val->pNext);
565 size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self(val);
566
567 return size;
568 }
569
570 static inline void
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_pnext(struct vn_cs_decoder * dec,const void * val)571 vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_pnext(struct vn_cs_decoder *dec, const void *val)
572 {
573 /* no known/supported struct */
574 if (vn_decode_simple_pointer(dec))
575 assert(false);
576 }
577
578 static inline void
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(struct vn_cs_decoder * dec,VkMemoryResourceAllocationSizePropertiesMESA * val)579 vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(struct vn_cs_decoder *dec, VkMemoryResourceAllocationSizePropertiesMESA *val)
580 {
581 /* skip val->{sType,pNext} */
582 vn_decode_uint64_t(dec, &val->allocationSize);
583 }
584
585 static inline void
vn_decode_VkMemoryResourceAllocationSizePropertiesMESA(struct vn_cs_decoder * dec,VkMemoryResourceAllocationSizePropertiesMESA * val)586 vn_decode_VkMemoryResourceAllocationSizePropertiesMESA(struct vn_cs_decoder *dec, VkMemoryResourceAllocationSizePropertiesMESA *val)
587 {
588 VkStructureType stype;
589 vn_decode_VkStructureType(dec, &stype);
590 assert(stype == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA);
591
592 assert(val->sType == stype);
593 vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_pnext(dec, val->pNext);
594 vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(dec, val);
595 }
596
597 static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(const void * val)598 vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(const void *val)
599 {
600 /* no known/supported struct */
601 return vn_sizeof_simple_pointer(NULL);
602 }
603
604 static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(const VkMemoryResourceAllocationSizePropertiesMESA * val)605 vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(const VkMemoryResourceAllocationSizePropertiesMESA *val)
606 {
607 size_t size = 0;
608 /* skip val->{sType,pNext} */
609 /* skip val->allocationSize */
610 return size;
611 }
612
613 static inline size_t
vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_partial(const VkMemoryResourceAllocationSizePropertiesMESA * val)614 vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_partial(const VkMemoryResourceAllocationSizePropertiesMESA *val)
615 {
616 size_t size = 0;
617
618 size += vn_sizeof_VkStructureType(&val->sType);
619 size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(val->pNext);
620 size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(val);
621
622 return size;
623 }
624
625 static inline void
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(struct vn_cs_encoder * enc,const void * val)626 vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(struct vn_cs_encoder *enc, const void *val)
627 {
628 /* no known/supported struct */
629 vn_encode_simple_pointer(enc, NULL);
630 }
631
632 static inline void
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(struct vn_cs_encoder * enc,const VkMemoryResourceAllocationSizePropertiesMESA * val)633 vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(struct vn_cs_encoder *enc, const VkMemoryResourceAllocationSizePropertiesMESA *val)
634 {
635 /* skip val->{sType,pNext} */
636 /* skip val->allocationSize */
637 }
638
639 static inline void
vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_partial(struct vn_cs_encoder * enc,const VkMemoryResourceAllocationSizePropertiesMESA * val)640 vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_partial(struct vn_cs_encoder *enc, const VkMemoryResourceAllocationSizePropertiesMESA *val)
641 {
642 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA);
643 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA });
644 vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_pnext_partial(enc, val->pNext);
645 vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(enc, val);
646 }
647
648 /* struct VkMemoryResourcePropertiesMESA chain */
649
650 static inline size_t
vn_sizeof_VkMemoryResourcePropertiesMESA_pnext(const void * val)651 vn_sizeof_VkMemoryResourcePropertiesMESA_pnext(const void *val)
652 {
653 const VkBaseInStructure *pnext = val;
654 size_t size = 0;
655
656 while (pnext) {
657 switch ((int32_t)pnext->sType) {
658 case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
659 size += vn_sizeof_simple_pointer(pnext);
660 size += vn_sizeof_VkStructureType(&pnext->sType);
661 size += vn_sizeof_VkMemoryResourcePropertiesMESA_pnext(pnext->pNext);
662 size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self((const VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
663 return size;
664 default:
665 /* ignore unknown/unsupported struct */
666 break;
667 }
668 pnext = pnext->pNext;
669 }
670
671 return vn_sizeof_simple_pointer(NULL);
672 }
673
674 static inline size_t
vn_sizeof_VkMemoryResourcePropertiesMESA_self(const VkMemoryResourcePropertiesMESA * val)675 vn_sizeof_VkMemoryResourcePropertiesMESA_self(const VkMemoryResourcePropertiesMESA *val)
676 {
677 size_t size = 0;
678 /* skip val->{sType,pNext} */
679 size += vn_sizeof_uint32_t(&val->memoryTypeBits);
680 return size;
681 }
682
683 static inline size_t
vn_sizeof_VkMemoryResourcePropertiesMESA(const VkMemoryResourcePropertiesMESA * val)684 vn_sizeof_VkMemoryResourcePropertiesMESA(const VkMemoryResourcePropertiesMESA *val)
685 {
686 size_t size = 0;
687
688 size += vn_sizeof_VkStructureType(&val->sType);
689 size += vn_sizeof_VkMemoryResourcePropertiesMESA_pnext(val->pNext);
690 size += vn_sizeof_VkMemoryResourcePropertiesMESA_self(val);
691
692 return size;
693 }
694
695 static inline void
vn_decode_VkMemoryResourcePropertiesMESA_pnext(struct vn_cs_decoder * dec,const void * val)696 vn_decode_VkMemoryResourcePropertiesMESA_pnext(struct vn_cs_decoder *dec, const void *val)
697 {
698 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
699 VkStructureType stype;
700
701 if (!vn_decode_simple_pointer(dec))
702 return;
703
704 vn_decode_VkStructureType(dec, &stype);
705 while (true) {
706 assert(pnext);
707 if (pnext->sType == stype)
708 break;
709
710 pnext = pnext->pNext;
711 }
712
713 switch ((int32_t)pnext->sType) {
714 case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
715 vn_decode_VkMemoryResourcePropertiesMESA_pnext(dec, pnext->pNext);
716 vn_decode_VkMemoryResourceAllocationSizePropertiesMESA_self(dec, (VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
717 break;
718 default:
719 assert(false);
720 break;
721 }
722 }
723
724 static inline void
vn_decode_VkMemoryResourcePropertiesMESA_self(struct vn_cs_decoder * dec,VkMemoryResourcePropertiesMESA * val)725 vn_decode_VkMemoryResourcePropertiesMESA_self(struct vn_cs_decoder *dec, VkMemoryResourcePropertiesMESA *val)
726 {
727 /* skip val->{sType,pNext} */
728 vn_decode_uint32_t(dec, &val->memoryTypeBits);
729 }
730
731 static inline void
vn_decode_VkMemoryResourcePropertiesMESA(struct vn_cs_decoder * dec,VkMemoryResourcePropertiesMESA * val)732 vn_decode_VkMemoryResourcePropertiesMESA(struct vn_cs_decoder *dec, VkMemoryResourcePropertiesMESA *val)
733 {
734 VkStructureType stype;
735 vn_decode_VkStructureType(dec, &stype);
736 assert(stype == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_PROPERTIES_MESA);
737
738 assert(val->sType == stype);
739 vn_decode_VkMemoryResourcePropertiesMESA_pnext(dec, val->pNext);
740 vn_decode_VkMemoryResourcePropertiesMESA_self(dec, val);
741 }
742
743 static inline size_t
vn_sizeof_VkMemoryResourcePropertiesMESA_pnext_partial(const void * val)744 vn_sizeof_VkMemoryResourcePropertiesMESA_pnext_partial(const void *val)
745 {
746 const VkBaseInStructure *pnext = val;
747 size_t size = 0;
748
749 while (pnext) {
750 switch ((int32_t)pnext->sType) {
751 case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
752 size += vn_sizeof_simple_pointer(pnext);
753 size += vn_sizeof_VkStructureType(&pnext->sType);
754 size += vn_sizeof_VkMemoryResourcePropertiesMESA_pnext_partial(pnext->pNext);
755 size += vn_sizeof_VkMemoryResourceAllocationSizePropertiesMESA_self_partial((const VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
756 return size;
757 default:
758 /* ignore unknown/unsupported struct */
759 break;
760 }
761 pnext = pnext->pNext;
762 }
763
764 return vn_sizeof_simple_pointer(NULL);
765 }
766
767 static inline size_t
vn_sizeof_VkMemoryResourcePropertiesMESA_self_partial(const VkMemoryResourcePropertiesMESA * val)768 vn_sizeof_VkMemoryResourcePropertiesMESA_self_partial(const VkMemoryResourcePropertiesMESA *val)
769 {
770 size_t size = 0;
771 /* skip val->{sType,pNext} */
772 /* skip val->memoryTypeBits */
773 return size;
774 }
775
776 static inline size_t
vn_sizeof_VkMemoryResourcePropertiesMESA_partial(const VkMemoryResourcePropertiesMESA * val)777 vn_sizeof_VkMemoryResourcePropertiesMESA_partial(const VkMemoryResourcePropertiesMESA *val)
778 {
779 size_t size = 0;
780
781 size += vn_sizeof_VkStructureType(&val->sType);
782 size += vn_sizeof_VkMemoryResourcePropertiesMESA_pnext_partial(val->pNext);
783 size += vn_sizeof_VkMemoryResourcePropertiesMESA_self_partial(val);
784
785 return size;
786 }
787
788 static inline void
vn_encode_VkMemoryResourcePropertiesMESA_pnext_partial(struct vn_cs_encoder * enc,const void * val)789 vn_encode_VkMemoryResourcePropertiesMESA_pnext_partial(struct vn_cs_encoder *enc, const void *val)
790 {
791 const VkBaseInStructure *pnext = val;
792
793 while (pnext) {
794 switch ((int32_t)pnext->sType) {
795 case VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA:
796 vn_encode_simple_pointer(enc, pnext);
797 vn_encode_VkStructureType(enc, &pnext->sType);
798 vn_encode_VkMemoryResourcePropertiesMESA_pnext_partial(enc, pnext->pNext);
799 vn_encode_VkMemoryResourceAllocationSizePropertiesMESA_self_partial(enc, (const VkMemoryResourceAllocationSizePropertiesMESA *)pnext);
800 return;
801 default:
802 /* ignore unknown/unsupported struct */
803 break;
804 }
805 pnext = pnext->pNext;
806 }
807
808 vn_encode_simple_pointer(enc, NULL);
809 }
810
811 static inline void
vn_encode_VkMemoryResourcePropertiesMESA_self_partial(struct vn_cs_encoder * enc,const VkMemoryResourcePropertiesMESA * val)812 vn_encode_VkMemoryResourcePropertiesMESA_self_partial(struct vn_cs_encoder *enc, const VkMemoryResourcePropertiesMESA *val)
813 {
814 /* skip val->{sType,pNext} */
815 /* skip val->memoryTypeBits */
816 }
817
818 static inline void
vn_encode_VkMemoryResourcePropertiesMESA_partial(struct vn_cs_encoder * enc,const VkMemoryResourcePropertiesMESA * val)819 vn_encode_VkMemoryResourcePropertiesMESA_partial(struct vn_cs_encoder *enc, const VkMemoryResourcePropertiesMESA *val)
820 {
821 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_RESOURCE_PROPERTIES_MESA);
822 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_RESOURCE_PROPERTIES_MESA });
823 vn_encode_VkMemoryResourcePropertiesMESA_pnext_partial(enc, val->pNext);
824 vn_encode_VkMemoryResourcePropertiesMESA_self_partial(enc, val);
825 }
826
vn_sizeof_vkAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)827 static inline size_t vn_sizeof_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
828 {
829 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
830 const VkFlags cmd_flags = 0;
831 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
832
833 cmd_size += vn_sizeof_VkDevice(&device);
834 cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
835 if (pAllocateInfo)
836 cmd_size += vn_sizeof_VkMemoryAllocateInfo(pAllocateInfo);
837 cmd_size += vn_sizeof_simple_pointer(pAllocator);
838 if (pAllocator)
839 assert(false);
840 cmd_size += vn_sizeof_simple_pointer(pMemory);
841 if (pMemory)
842 cmd_size += vn_sizeof_VkDeviceMemory(pMemory);
843
844 return cmd_size;
845 }
846
vn_encode_vkAllocateMemory(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)847 static inline void vn_encode_vkAllocateMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
848 {
849 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
850
851 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
852 vn_encode_VkFlags(enc, &cmd_flags);
853
854 vn_encode_VkDevice(enc, &device);
855 if (vn_encode_simple_pointer(enc, pAllocateInfo))
856 vn_encode_VkMemoryAllocateInfo(enc, pAllocateInfo);
857 if (vn_encode_simple_pointer(enc, pAllocator))
858 assert(false);
859 if (vn_encode_simple_pointer(enc, pMemory))
860 vn_encode_VkDeviceMemory(enc, pMemory);
861 }
862
vn_sizeof_vkAllocateMemory_reply(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)863 static inline size_t vn_sizeof_vkAllocateMemory_reply(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
864 {
865 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT;
866 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
867
868 VkResult ret;
869 cmd_size += vn_sizeof_VkResult(&ret);
870 /* skip device */
871 /* skip pAllocateInfo */
872 /* skip pAllocator */
873 cmd_size += vn_sizeof_simple_pointer(pMemory);
874 if (pMemory)
875 cmd_size += vn_sizeof_VkDeviceMemory(pMemory);
876
877 return cmd_size;
878 }
879
vn_decode_vkAllocateMemory_reply(struct vn_cs_decoder * dec,VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)880 static inline VkResult vn_decode_vkAllocateMemory_reply(struct vn_cs_decoder *dec, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
881 {
882 VkCommandTypeEXT command_type;
883 vn_decode_VkCommandTypeEXT(dec, &command_type);
884 assert(command_type == VK_COMMAND_TYPE_vkAllocateMemory_EXT);
885
886 VkResult ret;
887 vn_decode_VkResult(dec, &ret);
888 /* skip device */
889 /* skip pAllocateInfo */
890 /* skip pAllocator */
891 if (vn_decode_simple_pointer(dec)) {
892 vn_decode_VkDeviceMemory(dec, pMemory);
893 } else {
894 pMemory = NULL;
895 }
896
897 return ret;
898 }
899
vn_sizeof_vkFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)900 static inline size_t vn_sizeof_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
901 {
902 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
903 const VkFlags cmd_flags = 0;
904 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
905
906 cmd_size += vn_sizeof_VkDevice(&device);
907 cmd_size += vn_sizeof_VkDeviceMemory(&memory);
908 cmd_size += vn_sizeof_simple_pointer(pAllocator);
909 if (pAllocator)
910 assert(false);
911
912 return cmd_size;
913 }
914
vn_encode_vkFreeMemory(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)915 static inline void vn_encode_vkFreeMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
916 {
917 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
918
919 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
920 vn_encode_VkFlags(enc, &cmd_flags);
921
922 vn_encode_VkDevice(enc, &device);
923 vn_encode_VkDeviceMemory(enc, &memory);
924 if (vn_encode_simple_pointer(enc, pAllocator))
925 assert(false);
926 }
927
vn_sizeof_vkFreeMemory_reply(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)928 static inline size_t vn_sizeof_vkFreeMemory_reply(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
929 {
930 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT;
931 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
932
933 /* skip device */
934 /* skip memory */
935 /* skip pAllocator */
936
937 return cmd_size;
938 }
939
vn_decode_vkFreeMemory_reply(struct vn_cs_decoder * dec,VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)940 static inline void vn_decode_vkFreeMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
941 {
942 VkCommandTypeEXT command_type;
943 vn_decode_VkCommandTypeEXT(dec, &command_type);
944 assert(command_type == VK_COMMAND_TYPE_vkFreeMemory_EXT);
945
946 /* skip device */
947 /* skip memory */
948 /* skip pAllocator */
949 }
950
vn_sizeof_vkUnmapMemory(VkDevice device,VkDeviceMemory memory)951 static inline size_t vn_sizeof_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
952 {
953 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
954 const VkFlags cmd_flags = 0;
955 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
956
957 cmd_size += vn_sizeof_VkDevice(&device);
958 cmd_size += vn_sizeof_VkDeviceMemory(&memory);
959
960 return cmd_size;
961 }
962
vn_encode_vkUnmapMemory(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkDeviceMemory memory)963 static inline void vn_encode_vkUnmapMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory)
964 {
965 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
966
967 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
968 vn_encode_VkFlags(enc, &cmd_flags);
969
970 vn_encode_VkDevice(enc, &device);
971 vn_encode_VkDeviceMemory(enc, &memory);
972 }
973
vn_sizeof_vkUnmapMemory_reply(VkDevice device,VkDeviceMemory memory)974 static inline size_t vn_sizeof_vkUnmapMemory_reply(VkDevice device, VkDeviceMemory memory)
975 {
976 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT;
977 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
978
979 /* skip device */
980 /* skip memory */
981
982 return cmd_size;
983 }
984
vn_decode_vkUnmapMemory_reply(struct vn_cs_decoder * dec,VkDevice device,VkDeviceMemory memory)985 static inline void vn_decode_vkUnmapMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory)
986 {
987 VkCommandTypeEXT command_type;
988 vn_decode_VkCommandTypeEXT(dec, &command_type);
989 assert(command_type == VK_COMMAND_TYPE_vkUnmapMemory_EXT);
990
991 /* skip device */
992 /* skip memory */
993 }
994
vn_sizeof_vkFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)995 static inline size_t vn_sizeof_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
996 {
997 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
998 const VkFlags cmd_flags = 0;
999 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1000
1001 cmd_size += vn_sizeof_VkDevice(&device);
1002 cmd_size += vn_sizeof_uint32_t(&memoryRangeCount);
1003 if (pMemoryRanges) {
1004 cmd_size += vn_sizeof_array_size(memoryRangeCount);
1005 for (uint32_t i = 0; i < memoryRangeCount; i++)
1006 cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]);
1007 } else {
1008 cmd_size += vn_sizeof_array_size(0);
1009 }
1010
1011 return cmd_size;
1012 }
1013
vn_encode_vkFlushMappedMemoryRanges(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1014 static inline void vn_encode_vkFlushMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1015 {
1016 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
1017
1018 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1019 vn_encode_VkFlags(enc, &cmd_flags);
1020
1021 vn_encode_VkDevice(enc, &device);
1022 vn_encode_uint32_t(enc, &memoryRangeCount);
1023 if (pMemoryRanges) {
1024 vn_encode_array_size(enc, memoryRangeCount);
1025 for (uint32_t i = 0; i < memoryRangeCount; i++)
1026 vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]);
1027 } else {
1028 vn_encode_array_size(enc, 0);
1029 }
1030 }
1031
vn_sizeof_vkFlushMappedMemoryRanges_reply(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1032 static inline size_t vn_sizeof_vkFlushMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1033 {
1034 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT;
1035 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1036
1037 VkResult ret;
1038 cmd_size += vn_sizeof_VkResult(&ret);
1039 /* skip device */
1040 /* skip memoryRangeCount */
1041 /* skip pMemoryRanges */
1042
1043 return cmd_size;
1044 }
1045
vn_decode_vkFlushMappedMemoryRanges_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1046 static inline VkResult vn_decode_vkFlushMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1047 {
1048 VkCommandTypeEXT command_type;
1049 vn_decode_VkCommandTypeEXT(dec, &command_type);
1050 assert(command_type == VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT);
1051
1052 VkResult ret;
1053 vn_decode_VkResult(dec, &ret);
1054 /* skip device */
1055 /* skip memoryRangeCount */
1056 /* skip pMemoryRanges */
1057
1058 return ret;
1059 }
1060
vn_sizeof_vkInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1061 static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1062 {
1063 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
1064 const VkFlags cmd_flags = 0;
1065 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1066
1067 cmd_size += vn_sizeof_VkDevice(&device);
1068 cmd_size += vn_sizeof_uint32_t(&memoryRangeCount);
1069 if (pMemoryRanges) {
1070 cmd_size += vn_sizeof_array_size(memoryRangeCount);
1071 for (uint32_t i = 0; i < memoryRangeCount; i++)
1072 cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]);
1073 } else {
1074 cmd_size += vn_sizeof_array_size(0);
1075 }
1076
1077 return cmd_size;
1078 }
1079
vn_encode_vkInvalidateMappedMemoryRanges(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1080 static inline void vn_encode_vkInvalidateMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1081 {
1082 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
1083
1084 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1085 vn_encode_VkFlags(enc, &cmd_flags);
1086
1087 vn_encode_VkDevice(enc, &device);
1088 vn_encode_uint32_t(enc, &memoryRangeCount);
1089 if (pMemoryRanges) {
1090 vn_encode_array_size(enc, memoryRangeCount);
1091 for (uint32_t i = 0; i < memoryRangeCount; i++)
1092 vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]);
1093 } else {
1094 vn_encode_array_size(enc, 0);
1095 }
1096 }
1097
vn_sizeof_vkInvalidateMappedMemoryRanges_reply(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1098 static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1099 {
1100 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT;
1101 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1102
1103 VkResult ret;
1104 cmd_size += vn_sizeof_VkResult(&ret);
1105 /* skip device */
1106 /* skip memoryRangeCount */
1107 /* skip pMemoryRanges */
1108
1109 return cmd_size;
1110 }
1111
vn_decode_vkInvalidateMappedMemoryRanges_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1112 static inline VkResult vn_decode_vkInvalidateMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1113 {
1114 VkCommandTypeEXT command_type;
1115 vn_decode_VkCommandTypeEXT(dec, &command_type);
1116 assert(command_type == VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT);
1117
1118 VkResult ret;
1119 vn_decode_VkResult(dec, &ret);
1120 /* skip device */
1121 /* skip memoryRangeCount */
1122 /* skip pMemoryRanges */
1123
1124 return ret;
1125 }
1126
vn_sizeof_vkGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)1127 static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
1128 {
1129 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
1130 const VkFlags cmd_flags = 0;
1131 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1132
1133 cmd_size += vn_sizeof_VkDevice(&device);
1134 cmd_size += vn_sizeof_VkDeviceMemory(&memory);
1135 cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes); /* out */
1136
1137 return cmd_size;
1138 }
1139
vn_encode_vkGetDeviceMemoryCommitment(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)1140 static inline void vn_encode_vkGetDeviceMemoryCommitment(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
1141 {
1142 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
1143
1144 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1145 vn_encode_VkFlags(enc, &cmd_flags);
1146
1147 vn_encode_VkDevice(enc, &device);
1148 vn_encode_VkDeviceMemory(enc, &memory);
1149 vn_encode_simple_pointer(enc, pCommittedMemoryInBytes); /* out */
1150 }
1151
vn_sizeof_vkGetDeviceMemoryCommitment_reply(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)1152 static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment_reply(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
1153 {
1154 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT;
1155 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1156
1157 /* skip device */
1158 /* skip memory */
1159 cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes);
1160 if (pCommittedMemoryInBytes)
1161 cmd_size += vn_sizeof_VkDeviceSize(pCommittedMemoryInBytes);
1162
1163 return cmd_size;
1164 }
1165
vn_decode_vkGetDeviceMemoryCommitment_reply(struct vn_cs_decoder * dec,VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)1166 static inline void vn_decode_vkGetDeviceMemoryCommitment_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
1167 {
1168 VkCommandTypeEXT command_type;
1169 vn_decode_VkCommandTypeEXT(dec, &command_type);
1170 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT);
1171
1172 /* skip device */
1173 /* skip memory */
1174 if (vn_decode_simple_pointer(dec)) {
1175 vn_decode_VkDeviceSize(dec, pCommittedMemoryInBytes);
1176 } else {
1177 pCommittedMemoryInBytes = NULL;
1178 }
1179 }
1180
vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo)1181 static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1182 {
1183 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
1184 const VkFlags cmd_flags = 0;
1185 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1186
1187 cmd_size += vn_sizeof_VkDevice(&device);
1188 cmd_size += vn_sizeof_simple_pointer(pInfo);
1189 if (pInfo)
1190 cmd_size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(pInfo);
1191
1192 return cmd_size;
1193 }
1194
vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo)1195 static inline void vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1196 {
1197 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
1198
1199 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1200 vn_encode_VkFlags(enc, &cmd_flags);
1201
1202 vn_encode_VkDevice(enc, &device);
1203 if (vn_encode_simple_pointer(enc, pInfo))
1204 vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(enc, pInfo);
1205 }
1206
vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo)1207 static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1208 {
1209 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT;
1210 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1211
1212 uint64_t ret;
1213 cmd_size += vn_sizeof_uint64_t(&ret);
1214 /* skip device */
1215 /* skip pInfo */
1216
1217 return cmd_size;
1218 }
1219
vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo)1220 static inline uint64_t vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1221 {
1222 VkCommandTypeEXT command_type;
1223 vn_decode_VkCommandTypeEXT(dec, &command_type);
1224 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT);
1225
1226 uint64_t ret;
1227 vn_decode_uint64_t(dec, &ret);
1228 /* skip device */
1229 /* skip pInfo */
1230
1231 return ret;
1232 }
1233
vn_sizeof_vkGetMemoryResourcePropertiesMESA(VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties)1234 static inline size_t vn_sizeof_vkGetMemoryResourcePropertiesMESA(VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties)
1235 {
1236 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetMemoryResourcePropertiesMESA_EXT;
1237 const VkFlags cmd_flags = 0;
1238 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1239
1240 cmd_size += vn_sizeof_VkDevice(&device);
1241 cmd_size += vn_sizeof_uint32_t(&resourceId);
1242 cmd_size += vn_sizeof_simple_pointer(pMemoryResourceProperties);
1243 if (pMemoryResourceProperties)
1244 cmd_size += vn_sizeof_VkMemoryResourcePropertiesMESA_partial(pMemoryResourceProperties);
1245
1246 return cmd_size;
1247 }
1248
vn_encode_vkGetMemoryResourcePropertiesMESA(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties)1249 static inline void vn_encode_vkGetMemoryResourcePropertiesMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties)
1250 {
1251 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetMemoryResourcePropertiesMESA_EXT;
1252
1253 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1254 vn_encode_VkFlags(enc, &cmd_flags);
1255
1256 vn_encode_VkDevice(enc, &device);
1257 vn_encode_uint32_t(enc, &resourceId);
1258 if (vn_encode_simple_pointer(enc, pMemoryResourceProperties))
1259 vn_encode_VkMemoryResourcePropertiesMESA_partial(enc, pMemoryResourceProperties);
1260 }
1261
vn_sizeof_vkGetMemoryResourcePropertiesMESA_reply(VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties)1262 static inline size_t vn_sizeof_vkGetMemoryResourcePropertiesMESA_reply(VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties)
1263 {
1264 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetMemoryResourcePropertiesMESA_EXT;
1265 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1266
1267 VkResult ret;
1268 cmd_size += vn_sizeof_VkResult(&ret);
1269 /* skip device */
1270 /* skip resourceId */
1271 cmd_size += vn_sizeof_simple_pointer(pMemoryResourceProperties);
1272 if (pMemoryResourceProperties)
1273 cmd_size += vn_sizeof_VkMemoryResourcePropertiesMESA(pMemoryResourceProperties);
1274
1275 return cmd_size;
1276 }
1277
vn_decode_vkGetMemoryResourcePropertiesMESA_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties)1278 static inline VkResult vn_decode_vkGetMemoryResourcePropertiesMESA_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties)
1279 {
1280 VkCommandTypeEXT command_type;
1281 vn_decode_VkCommandTypeEXT(dec, &command_type);
1282 assert(command_type == VK_COMMAND_TYPE_vkGetMemoryResourcePropertiesMESA_EXT);
1283
1284 VkResult ret;
1285 vn_decode_VkResult(dec, &ret);
1286 /* skip device */
1287 /* skip resourceId */
1288 if (vn_decode_simple_pointer(dec)) {
1289 vn_decode_VkMemoryResourcePropertiesMESA(dec, pMemoryResourceProperties);
1290 } else {
1291 pMemoryResourceProperties = NULL;
1292 }
1293
1294 return ret;
1295 }
1296
vn_submit_vkAllocateMemory(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory,struct vn_ring_submit_command * submit)1297 static inline void vn_submit_vkAllocateMemory(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, struct vn_ring_submit_command *submit)
1298 {
1299 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1300 void *cmd_data = local_cmd_data;
1301 size_t cmd_size = vn_sizeof_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
1302 if (cmd_size > sizeof(local_cmd_data)) {
1303 cmd_data = malloc(cmd_size);
1304 if (!cmd_data)
1305 cmd_size = 0;
1306 }
1307 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateMemory_reply(device, pAllocateInfo, pAllocator, pMemory) : 0;
1308
1309 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1310 if (cmd_size) {
1311 vn_encode_vkAllocateMemory(enc, cmd_flags, device, pAllocateInfo, pAllocator, pMemory);
1312 vn_ring_submit_command(vn_ring, submit);
1313 if (cmd_data != local_cmd_data)
1314 free(cmd_data);
1315 }
1316 }
1317
vn_submit_vkFreeMemory(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator,struct vn_ring_submit_command * submit)1318 static inline void vn_submit_vkFreeMemory(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator, struct vn_ring_submit_command *submit)
1319 {
1320 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1321 void *cmd_data = local_cmd_data;
1322 size_t cmd_size = vn_sizeof_vkFreeMemory(device, memory, pAllocator);
1323 if (cmd_size > sizeof(local_cmd_data)) {
1324 cmd_data = malloc(cmd_size);
1325 if (!cmd_data)
1326 cmd_size = 0;
1327 }
1328 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeMemory_reply(device, memory, pAllocator) : 0;
1329
1330 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1331 if (cmd_size) {
1332 vn_encode_vkFreeMemory(enc, cmd_flags, device, memory, pAllocator);
1333 vn_ring_submit_command(vn_ring, submit);
1334 if (cmd_data != local_cmd_data)
1335 free(cmd_data);
1336 }
1337 }
1338
vn_submit_vkUnmapMemory(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkDeviceMemory memory,struct vn_ring_submit_command * submit)1339 static inline void vn_submit_vkUnmapMemory(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, struct vn_ring_submit_command *submit)
1340 {
1341 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1342 void *cmd_data = local_cmd_data;
1343 size_t cmd_size = vn_sizeof_vkUnmapMemory(device, memory);
1344 if (cmd_size > sizeof(local_cmd_data)) {
1345 cmd_data = malloc(cmd_size);
1346 if (!cmd_data)
1347 cmd_size = 0;
1348 }
1349 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUnmapMemory_reply(device, memory) : 0;
1350
1351 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1352 if (cmd_size) {
1353 vn_encode_vkUnmapMemory(enc, cmd_flags, device, memory);
1354 vn_ring_submit_command(vn_ring, submit);
1355 if (cmd_data != local_cmd_data)
1356 free(cmd_data);
1357 }
1358 }
1359
vn_submit_vkFlushMappedMemoryRanges(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges,struct vn_ring_submit_command * submit)1360 static inline void vn_submit_vkFlushMappedMemoryRanges(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_ring_submit_command *submit)
1361 {
1362 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1363 void *cmd_data = local_cmd_data;
1364 size_t cmd_size = vn_sizeof_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
1365 if (cmd_size > sizeof(local_cmd_data)) {
1366 cmd_data = malloc(cmd_size);
1367 if (!cmd_data)
1368 cmd_size = 0;
1369 }
1370 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFlushMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
1371
1372 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1373 if (cmd_size) {
1374 vn_encode_vkFlushMappedMemoryRanges(enc, cmd_flags, device, memoryRangeCount, pMemoryRanges);
1375 vn_ring_submit_command(vn_ring, submit);
1376 if (cmd_data != local_cmd_data)
1377 free(cmd_data);
1378 }
1379 }
1380
vn_submit_vkInvalidateMappedMemoryRanges(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges,struct vn_ring_submit_command * submit)1381 static inline void vn_submit_vkInvalidateMappedMemoryRanges(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_ring_submit_command *submit)
1382 {
1383 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1384 void *cmd_data = local_cmd_data;
1385 size_t cmd_size = vn_sizeof_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
1386 if (cmd_size > sizeof(local_cmd_data)) {
1387 cmd_data = malloc(cmd_size);
1388 if (!cmd_data)
1389 cmd_size = 0;
1390 }
1391 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkInvalidateMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
1392
1393 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1394 if (cmd_size) {
1395 vn_encode_vkInvalidateMappedMemoryRanges(enc, cmd_flags, device, memoryRangeCount, pMemoryRanges);
1396 vn_ring_submit_command(vn_ring, submit);
1397 if (cmd_data != local_cmd_data)
1398 free(cmd_data);
1399 }
1400 }
1401
vn_submit_vkGetDeviceMemoryCommitment(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes,struct vn_ring_submit_command * submit)1402 static inline void vn_submit_vkGetDeviceMemoryCommitment(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes, struct vn_ring_submit_command *submit)
1403 {
1404 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1405 void *cmd_data = local_cmd_data;
1406 size_t cmd_size = vn_sizeof_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
1407 if (cmd_size > sizeof(local_cmd_data)) {
1408 cmd_data = malloc(cmd_size);
1409 if (!cmd_data)
1410 cmd_size = 0;
1411 }
1412 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryCommitment_reply(device, memory, pCommittedMemoryInBytes) : 0;
1413
1414 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1415 if (cmd_size) {
1416 vn_encode_vkGetDeviceMemoryCommitment(enc, cmd_flags, device, memory, pCommittedMemoryInBytes);
1417 vn_ring_submit_command(vn_ring, submit);
1418 if (cmd_data != local_cmd_data)
1419 free(cmd_data);
1420 }
1421 }
1422
vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo,struct vn_ring_submit_command * submit)1423 static inline void vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, struct vn_ring_submit_command *submit)
1424 {
1425 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1426 void *cmd_data = local_cmd_data;
1427 size_t cmd_size = vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
1428 if (cmd_size > sizeof(local_cmd_data)) {
1429 cmd_data = malloc(cmd_size);
1430 if (!cmd_data)
1431 cmd_size = 0;
1432 }
1433 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(device, pInfo) : 0;
1434
1435 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1436 if (cmd_size) {
1437 vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(enc, cmd_flags, device, pInfo);
1438 vn_ring_submit_command(vn_ring, submit);
1439 if (cmd_data != local_cmd_data)
1440 free(cmd_data);
1441 }
1442 }
1443
vn_submit_vkGetMemoryResourcePropertiesMESA(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties,struct vn_ring_submit_command * submit)1444 static inline void vn_submit_vkGetMemoryResourcePropertiesMESA(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties, struct vn_ring_submit_command *submit)
1445 {
1446 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1447 void *cmd_data = local_cmd_data;
1448 size_t cmd_size = vn_sizeof_vkGetMemoryResourcePropertiesMESA(device, resourceId, pMemoryResourceProperties);
1449 if (cmd_size > sizeof(local_cmd_data)) {
1450 cmd_data = malloc(cmd_size);
1451 if (!cmd_data)
1452 cmd_size = 0;
1453 }
1454 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetMemoryResourcePropertiesMESA_reply(device, resourceId, pMemoryResourceProperties) : 0;
1455
1456 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1457 if (cmd_size) {
1458 vn_encode_vkGetMemoryResourcePropertiesMESA(enc, cmd_flags, device, resourceId, pMemoryResourceProperties);
1459 vn_ring_submit_command(vn_ring, submit);
1460 if (cmd_data != local_cmd_data)
1461 free(cmd_data);
1462 }
1463 }
1464
vn_call_vkAllocateMemory(struct vn_ring * vn_ring,VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)1465 static inline VkResult vn_call_vkAllocateMemory(struct vn_ring *vn_ring, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
1466 {
1467 VN_TRACE_FUNC();
1468
1469 struct vn_ring_submit_command submit;
1470 vn_submit_vkAllocateMemory(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pAllocator, pMemory, &submit);
1471 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1472 if (dec) {
1473 const VkResult ret = vn_decode_vkAllocateMemory_reply(dec, device, pAllocateInfo, pAllocator, pMemory);
1474 vn_ring_free_command_reply(vn_ring, &submit);
1475 return ret;
1476 } else {
1477 return VK_ERROR_OUT_OF_HOST_MEMORY;
1478 }
1479 }
1480
vn_async_vkAllocateMemory(struct vn_ring * vn_ring,VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)1481 static inline void vn_async_vkAllocateMemory(struct vn_ring *vn_ring, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
1482 {
1483 struct vn_ring_submit_command submit;
1484 vn_submit_vkAllocateMemory(vn_ring, 0, device, pAllocateInfo, pAllocator, pMemory, &submit);
1485 }
1486
vn_call_vkFreeMemory(struct vn_ring * vn_ring,VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)1487 static inline void vn_call_vkFreeMemory(struct vn_ring *vn_ring, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
1488 {
1489 VN_TRACE_FUNC();
1490
1491 struct vn_ring_submit_command submit;
1492 vn_submit_vkFreeMemory(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pAllocator, &submit);
1493 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1494 if (dec) {
1495 vn_decode_vkFreeMemory_reply(dec, device, memory, pAllocator);
1496 vn_ring_free_command_reply(vn_ring, &submit);
1497 }
1498 }
1499
vn_async_vkFreeMemory(struct vn_ring * vn_ring,VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)1500 static inline void vn_async_vkFreeMemory(struct vn_ring *vn_ring, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
1501 {
1502 struct vn_ring_submit_command submit;
1503 vn_submit_vkFreeMemory(vn_ring, 0, device, memory, pAllocator, &submit);
1504 }
1505
vn_call_vkUnmapMemory(struct vn_ring * vn_ring,VkDevice device,VkDeviceMemory memory)1506 static inline void vn_call_vkUnmapMemory(struct vn_ring *vn_ring, VkDevice device, VkDeviceMemory memory)
1507 {
1508 VN_TRACE_FUNC();
1509
1510 struct vn_ring_submit_command submit;
1511 vn_submit_vkUnmapMemory(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, &submit);
1512 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1513 if (dec) {
1514 vn_decode_vkUnmapMemory_reply(dec, device, memory);
1515 vn_ring_free_command_reply(vn_ring, &submit);
1516 }
1517 }
1518
vn_async_vkUnmapMemory(struct vn_ring * vn_ring,VkDevice device,VkDeviceMemory memory)1519 static inline void vn_async_vkUnmapMemory(struct vn_ring *vn_ring, VkDevice device, VkDeviceMemory memory)
1520 {
1521 struct vn_ring_submit_command submit;
1522 vn_submit_vkUnmapMemory(vn_ring, 0, device, memory, &submit);
1523 }
1524
vn_call_vkFlushMappedMemoryRanges(struct vn_ring * vn_ring,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1525 static inline VkResult vn_call_vkFlushMappedMemoryRanges(struct vn_ring *vn_ring, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1526 {
1527 VN_TRACE_FUNC();
1528
1529 struct vn_ring_submit_command submit;
1530 vn_submit_vkFlushMappedMemoryRanges(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
1531 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1532 if (dec) {
1533 const VkResult ret = vn_decode_vkFlushMappedMemoryRanges_reply(dec, device, memoryRangeCount, pMemoryRanges);
1534 vn_ring_free_command_reply(vn_ring, &submit);
1535 return ret;
1536 } else {
1537 return VK_ERROR_OUT_OF_HOST_MEMORY;
1538 }
1539 }
1540
vn_async_vkFlushMappedMemoryRanges(struct vn_ring * vn_ring,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1541 static inline void vn_async_vkFlushMappedMemoryRanges(struct vn_ring *vn_ring, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1542 {
1543 struct vn_ring_submit_command submit;
1544 vn_submit_vkFlushMappedMemoryRanges(vn_ring, 0, device, memoryRangeCount, pMemoryRanges, &submit);
1545 }
1546
vn_call_vkInvalidateMappedMemoryRanges(struct vn_ring * vn_ring,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1547 static inline VkResult vn_call_vkInvalidateMappedMemoryRanges(struct vn_ring *vn_ring, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1548 {
1549 VN_TRACE_FUNC();
1550
1551 struct vn_ring_submit_command submit;
1552 vn_submit_vkInvalidateMappedMemoryRanges(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
1553 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1554 if (dec) {
1555 const VkResult ret = vn_decode_vkInvalidateMappedMemoryRanges_reply(dec, device, memoryRangeCount, pMemoryRanges);
1556 vn_ring_free_command_reply(vn_ring, &submit);
1557 return ret;
1558 } else {
1559 return VK_ERROR_OUT_OF_HOST_MEMORY;
1560 }
1561 }
1562
vn_async_vkInvalidateMappedMemoryRanges(struct vn_ring * vn_ring,VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)1563 static inline void vn_async_vkInvalidateMappedMemoryRanges(struct vn_ring *vn_ring, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
1564 {
1565 struct vn_ring_submit_command submit;
1566 vn_submit_vkInvalidateMappedMemoryRanges(vn_ring, 0, device, memoryRangeCount, pMemoryRanges, &submit);
1567 }
1568
vn_call_vkGetDeviceMemoryCommitment(struct vn_ring * vn_ring,VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)1569 static inline void vn_call_vkGetDeviceMemoryCommitment(struct vn_ring *vn_ring, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
1570 {
1571 VN_TRACE_FUNC();
1572
1573 struct vn_ring_submit_command submit;
1574 vn_submit_vkGetDeviceMemoryCommitment(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pCommittedMemoryInBytes, &submit);
1575 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1576 if (dec) {
1577 vn_decode_vkGetDeviceMemoryCommitment_reply(dec, device, memory, pCommittedMemoryInBytes);
1578 vn_ring_free_command_reply(vn_ring, &submit);
1579 }
1580 }
1581
vn_async_vkGetDeviceMemoryCommitment(struct vn_ring * vn_ring,VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)1582 static inline void vn_async_vkGetDeviceMemoryCommitment(struct vn_ring *vn_ring, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
1583 {
1584 struct vn_ring_submit_command submit;
1585 vn_submit_vkGetDeviceMemoryCommitment(vn_ring, 0, device, memory, pCommittedMemoryInBytes, &submit);
1586 }
1587
vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ring * vn_ring,VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo)1588 static inline uint64_t vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ring *vn_ring, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1589 {
1590 VN_TRACE_FUNC();
1591
1592 struct vn_ring_submit_command submit;
1593 vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
1594 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1595 if (dec) {
1596 const uint64_t ret = vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(dec, device, pInfo);
1597 vn_ring_free_command_reply(vn_ring, &submit);
1598 return ret;
1599 } else {
1600 return VK_ERROR_OUT_OF_HOST_MEMORY;
1601 }
1602 }
1603
vn_async_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ring * vn_ring,VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo)1604 static inline void vn_async_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ring *vn_ring, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1605 {
1606 struct vn_ring_submit_command submit;
1607 vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_ring, 0, device, pInfo, &submit);
1608 }
1609
vn_call_vkGetMemoryResourcePropertiesMESA(struct vn_ring * vn_ring,VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties)1610 static inline VkResult vn_call_vkGetMemoryResourcePropertiesMESA(struct vn_ring *vn_ring, VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties)
1611 {
1612 VN_TRACE_FUNC();
1613
1614 struct vn_ring_submit_command submit;
1615 vn_submit_vkGetMemoryResourcePropertiesMESA(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, resourceId, pMemoryResourceProperties, &submit);
1616 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1617 if (dec) {
1618 const VkResult ret = vn_decode_vkGetMemoryResourcePropertiesMESA_reply(dec, device, resourceId, pMemoryResourceProperties);
1619 vn_ring_free_command_reply(vn_ring, &submit);
1620 return ret;
1621 } else {
1622 return VK_ERROR_OUT_OF_HOST_MEMORY;
1623 }
1624 }
1625
vn_async_vkGetMemoryResourcePropertiesMESA(struct vn_ring * vn_ring,VkDevice device,uint32_t resourceId,VkMemoryResourcePropertiesMESA * pMemoryResourceProperties)1626 static inline void vn_async_vkGetMemoryResourcePropertiesMESA(struct vn_ring *vn_ring, VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties)
1627 {
1628 struct vn_ring_submit_command submit;
1629 vn_submit_vkGetMemoryResourcePropertiesMESA(vn_ring, 0, device, resourceId, pMemoryResourceProperties, &submit);
1630 }
1631
1632 #endif /* VN_PROTOCOL_DRIVER_DEVICE_MEMORY_H */
1633