CoCalc -- vn_protocol_driver_command

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/src/virtio/venus-protocol/vn_protocol_driver_command_pool.h
⁴⁵⁶⁰ 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_COMMAND_POOL_H
9
#define VN_PROTOCOL_DRIVER_COMMAND_POOL_H
10

11
#include "vn_device.h"
12
#include "vn_protocol_driver_structs.h"
13

14
/* struct VkCommandPoolCreateInfo chain */
15

16
static inline size_t
17
vn_sizeof_VkCommandPoolCreateInfo_pnext(const void *val)
18
{
19
    /* no known/supported struct */
20
    return vn_sizeof_simple_pointer(NULL);
21
}
22

23
static inline size_t
24
vn_sizeof_VkCommandPoolCreateInfo_self(const VkCommandPoolCreateInfo *val)
25
{
26
    size_t size = 0;
27
    /* skip val->{sType,pNext} */
28
    size += vn_sizeof_VkFlags(&val->flags);
29
    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
30
    return size;
31
}
32

33
static inline size_t
34
vn_sizeof_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo *val)
35
{
36
    size_t size = 0;
37

38
    size += vn_sizeof_VkStructureType(&val->sType);
39
    size += vn_sizeof_VkCommandPoolCreateInfo_pnext(val->pNext);
40
    size += vn_sizeof_VkCommandPoolCreateInfo_self(val);
41

42
    return size;
43
}
44

45
static inline void
46
vn_encode_VkCommandPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
47
{
48
    /* no known/supported struct */
49
    vn_encode_simple_pointer(enc, NULL);
50
}
51

52
static inline void
53
vn_encode_VkCommandPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
54
{
55
    /* skip val->{sType,pNext} */
56
    vn_encode_VkFlags(enc, &val->flags);
57
    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
58
}
59

60
static inline void
61
vn_encode_VkCommandPoolCreateInfo(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
62
{
63
    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);
64
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO });
65
    vn_encode_VkCommandPoolCreateInfo_pnext(enc, val->pNext);
66
    vn_encode_VkCommandPoolCreateInfo_self(enc, val);
67
}
68

69
static inline size_t vn_sizeof_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
70
{
71
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
72
    const VkFlags cmd_flags = 0;
73
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
74

75
    cmd_size += vn_sizeof_VkDevice(&device);
76
    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
77
    if (pCreateInfo)
78
        cmd_size += vn_sizeof_VkCommandPoolCreateInfo(pCreateInfo);
79
    cmd_size += vn_sizeof_simple_pointer(pAllocator);
80
    if (pAllocator)
81
        assert(false);
82
    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
83
    if (pCommandPool)
84
        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
85

86
    return cmd_size;
87
}
88

89
static inline void vn_encode_vkCreateCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
90
{
91
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
92

93
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
94
    vn_encode_VkFlags(enc, &cmd_flags);
95

96
    vn_encode_VkDevice(enc, &device);
97
    if (vn_encode_simple_pointer(enc, pCreateInfo))
98
        vn_encode_VkCommandPoolCreateInfo(enc, pCreateInfo);
99
    if (vn_encode_simple_pointer(enc, pAllocator))
100
        assert(false);
101
    if (vn_encode_simple_pointer(enc, pCommandPool))
102
        vn_encode_VkCommandPool(enc, pCommandPool);
103
}
104

105
static inline size_t vn_sizeof_vkCreateCommandPool_reply(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
106
{
107
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
108
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
109

110
    VkResult ret;
111
    cmd_size += vn_sizeof_VkResult(&ret);
112
    /* skip device */
113
    /* skip pCreateInfo */
114
    /* skip pAllocator */
115
    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
116
    if (pCommandPool)
117
        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
118

119
    return cmd_size;
120
}
121

122
static inline VkResult vn_decode_vkCreateCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
123
{
124
    VkCommandTypeEXT command_type;
125
    vn_decode_VkCommandTypeEXT(dec, &command_type);
126
    assert(command_type == VK_COMMAND_TYPE_vkCreateCommandPool_EXT);
127

128
    VkResult ret;
129
    vn_decode_VkResult(dec, &ret);
130
    /* skip device */
131
    /* skip pCreateInfo */
132
    /* skip pAllocator */
133
    if (vn_decode_simple_pointer(dec)) {
134
        vn_decode_VkCommandPool(dec, pCommandPool);
135
    } else {
136
        pCommandPool = NULL;
137
    }
138

139
    return ret;
140
}
141

142
static inline size_t vn_sizeof_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
143
{
144
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
145
    const VkFlags cmd_flags = 0;
146
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
147

148
    cmd_size += vn_sizeof_VkDevice(&device);
149
    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
150
    cmd_size += vn_sizeof_simple_pointer(pAllocator);
151
    if (pAllocator)
152
        assert(false);
153

154
    return cmd_size;
155
}
156

157
static inline void vn_encode_vkDestroyCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
158
{
159
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
160

161
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
162
    vn_encode_VkFlags(enc, &cmd_flags);
163

164
    vn_encode_VkDevice(enc, &device);
165
    vn_encode_VkCommandPool(enc, &commandPool);
166
    if (vn_encode_simple_pointer(enc, pAllocator))
167
        assert(false);
168
}
169

170
static inline size_t vn_sizeof_vkDestroyCommandPool_reply(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
171
{
172
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
173
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
174

175
    /* skip device */
176
    /* skip commandPool */
177
    /* skip pAllocator */
178

179
    return cmd_size;
180
}
181

182
static inline void vn_decode_vkDestroyCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
183
{
184
    VkCommandTypeEXT command_type;
185
    vn_decode_VkCommandTypeEXT(dec, &command_type);
186
    assert(command_type == VK_COMMAND_TYPE_vkDestroyCommandPool_EXT);
187

188
    /* skip device */
189
    /* skip commandPool */
190
    /* skip pAllocator */
191
}
192

193
static inline size_t vn_sizeof_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
194
{
195
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
196
    const VkFlags cmd_flags = 0;
197
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
198

199
    cmd_size += vn_sizeof_VkDevice(&device);
200
    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
201
    cmd_size += vn_sizeof_VkFlags(&flags);
202

203
    return cmd_size;
204
}
205

206
static inline void vn_encode_vkResetCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
207
{
208
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
209

210
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
211
    vn_encode_VkFlags(enc, &cmd_flags);
212

213
    vn_encode_VkDevice(enc, &device);
214
    vn_encode_VkCommandPool(enc, &commandPool);
215
    vn_encode_VkFlags(enc, &flags);
216
}
217

218
static inline size_t vn_sizeof_vkResetCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
219
{
220
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
221
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
222

223
    VkResult ret;
224
    cmd_size += vn_sizeof_VkResult(&ret);
225
    /* skip device */
226
    /* skip commandPool */
227
    /* skip flags */
228

229
    return cmd_size;
230
}
231

232
static inline VkResult vn_decode_vkResetCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
233
{
234
    VkCommandTypeEXT command_type;
235
    vn_decode_VkCommandTypeEXT(dec, &command_type);
236
    assert(command_type == VK_COMMAND_TYPE_vkResetCommandPool_EXT);
237

238
    VkResult ret;
239
    vn_decode_VkResult(dec, &ret);
240
    /* skip device */
241
    /* skip commandPool */
242
    /* skip flags */
243

244
    return ret;
245
}
246

247
static inline size_t vn_sizeof_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
248
{
249
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
250
    const VkFlags cmd_flags = 0;
251
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
252

253
    cmd_size += vn_sizeof_VkDevice(&device);
254
    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
255
    cmd_size += vn_sizeof_VkFlags(&flags);
256

257
    return cmd_size;
258
}
259

260
static inline void vn_encode_vkTrimCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
261
{
262
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
263

264
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
265
    vn_encode_VkFlags(enc, &cmd_flags);
266

267
    vn_encode_VkDevice(enc, &device);
268
    vn_encode_VkCommandPool(enc, &commandPool);
269
    vn_encode_VkFlags(enc, &flags);
270
}
271

272
static inline size_t vn_sizeof_vkTrimCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
273
{
274
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
275
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
276

277
    /* skip device */
278
    /* skip commandPool */
279
    /* skip flags */
280

281
    return cmd_size;
282
}
283

284
static inline void vn_decode_vkTrimCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
285
{
286
    VkCommandTypeEXT command_type;
287
    vn_decode_VkCommandTypeEXT(dec, &command_type);
288
    assert(command_type == VK_COMMAND_TYPE_vkTrimCommandPool_EXT);
289

290
    /* skip device */
291
    /* skip commandPool */
292
    /* skip flags */
293
}
294

295
static inline void vn_submit_vkCreateCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, struct vn_instance_submit_command *submit)
296
{
297
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
298
    void *cmd_data = local_cmd_data;
299
    size_t cmd_size = vn_sizeof_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
300
    if (cmd_size > sizeof(local_cmd_data)) {
301
        cmd_data = malloc(cmd_size);
302
        if (!cmd_data)
303
            cmd_size = 0;
304
    }
305
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0;
306

307
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
308
    if (cmd_size) {
309
        vn_encode_vkCreateCommandPool(enc, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool);
310
        vn_instance_submit_command(vn_instance, submit);
311
        if (cmd_data != local_cmd_data)
312
            free(cmd_data);
313
    }
314
}
315

316
static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
317
{
318
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
319
    void *cmd_data = local_cmd_data;
320
    size_t cmd_size = vn_sizeof_vkDestroyCommandPool(device, commandPool, pAllocator);
321
    if (cmd_size > sizeof(local_cmd_data)) {
322
        cmd_data = malloc(cmd_size);
323
        if (!cmd_data)
324
            cmd_size = 0;
325
    }
326
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0;
327

328
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
329
    if (cmd_size) {
330
        vn_encode_vkDestroyCommandPool(enc, cmd_flags, device, commandPool, pAllocator);
331
        vn_instance_submit_command(vn_instance, submit);
332
        if (cmd_data != local_cmd_data)
333
            free(cmd_data);
334
    }
335
}
336

337
static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, struct vn_instance_submit_command *submit)
338
{
339
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
340
    void *cmd_data = local_cmd_data;
341
    size_t cmd_size = vn_sizeof_vkResetCommandPool(device, commandPool, flags);
342
    if (cmd_size > sizeof(local_cmd_data)) {
343
        cmd_data = malloc(cmd_size);
344
        if (!cmd_data)
345
            cmd_size = 0;
346
    }
347
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0;
348

349
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
350
    if (cmd_size) {
351
        vn_encode_vkResetCommandPool(enc, cmd_flags, device, commandPool, flags);
352
        vn_instance_submit_command(vn_instance, submit);
353
        if (cmd_data != local_cmd_data)
354
            free(cmd_data);
355
    }
356
}
357

358
static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, struct vn_instance_submit_command *submit)
359
{
360
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
361
    void *cmd_data = local_cmd_data;
362
    size_t cmd_size = vn_sizeof_vkTrimCommandPool(device, commandPool, flags);
363
    if (cmd_size > sizeof(local_cmd_data)) {
364
        cmd_data = malloc(cmd_size);
365
        if (!cmd_data)
366
            cmd_size = 0;
367
    }
368
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0;
369

370
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
371
    if (cmd_size) {
372
        vn_encode_vkTrimCommandPool(enc, cmd_flags, device, commandPool, flags);
373
        vn_instance_submit_command(vn_instance, submit);
374
        if (cmd_data != local_cmd_data)
375
            free(cmd_data);
376
    }
377
}
378

379
static inline VkResult vn_call_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
380
{
381
    struct vn_instance_submit_command submit;
382
    vn_submit_vkCreateCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pCommandPool, &submit);
383
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
384
    if (dec) {
385
        const VkResult ret = vn_decode_vkCreateCommandPool_reply(dec, device, pCreateInfo, pAllocator, pCommandPool);
386
        vn_instance_free_command_reply(vn_instance, &submit);
387
        return ret;
388
    } else {
389
        return VK_ERROR_OUT_OF_HOST_MEMORY;
390
    }
391
}
392

393
static inline void vn_async_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
394
{
395
    struct vn_instance_submit_command submit;
396
    vn_submit_vkCreateCommandPool(vn_instance, 0, device, pCreateInfo, pAllocator, pCommandPool, &submit);
397
}
398

399
static inline void vn_call_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
400
{
401
    struct vn_instance_submit_command submit;
402
    vn_submit_vkDestroyCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, pAllocator, &submit);
403
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
404
    if (dec) {
405
        vn_decode_vkDestroyCommandPool_reply(dec, device, commandPool, pAllocator);
406
        vn_instance_free_command_reply(vn_instance, &submit);
407
    }
408
}
409

410
static inline void vn_async_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
411
{
412
    struct vn_instance_submit_command submit;
413
    vn_submit_vkDestroyCommandPool(vn_instance, 0, device, commandPool, pAllocator, &submit);
414
}
415

416
static inline VkResult vn_call_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
417
{
418
    struct vn_instance_submit_command submit;
419
    vn_submit_vkResetCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
420
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
421
    if (dec) {
422
        const VkResult ret = vn_decode_vkResetCommandPool_reply(dec, device, commandPool, flags);
423
        vn_instance_free_command_reply(vn_instance, &submit);
424
        return ret;
425
    } else {
426
        return VK_ERROR_OUT_OF_HOST_MEMORY;
427
    }
428
}
429

430
static inline void vn_async_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
431
{
432
    struct vn_instance_submit_command submit;
433
    vn_submit_vkResetCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
434
}
435

436
static inline void vn_call_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
437
{
438
    struct vn_instance_submit_command submit;
439
    vn_submit_vkTrimCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
440
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
441
    if (dec) {
442
        vn_decode_vkTrimCommandPool_reply(dec, device, commandPool, flags);
443
        vn_instance_free_command_reply(vn_instance, &submit);
444
    }
445
}
446

447
static inline void vn_async_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
448
{
449
    struct vn_instance_submit_command submit;
450
    vn_submit_vkTrimCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
451
}
452

453
#endif /* VN_PROTOCOL_DRIVER_COMMAND_POOL_H */
454

455
Product

Resources

Company
