Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
PojavLauncherTeam
GitHub Repository: PojavLauncherTeam/mesa
 Path: blob/21.2-virgl/src/virtio/venus-protocol/vn_protocol_driver_sampler.h
4560 views
1
/* This file is generated by venus-protocol.  See vn_protocol_driver.h. */

2


3
/*

4
 * Copyright 2020 Google LLC

5
 * SPDX-License-Identifier: MIT

6
 */

7


8
#ifndef VN_PROTOCOL_DRIVER_SAMPLER_H

9
#define VN_PROTOCOL_DRIVER_SAMPLER_H

10


11
#include "vn_device.h"

12
#include "vn_protocol_driver_structs.h"

13


14
/* struct VkSamplerReductionModeCreateInfo chain */

15


16
static inline size_t

17
vn_sizeof_VkSamplerReductionModeCreateInfo_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_VkSamplerReductionModeCreateInfo_self(const VkSamplerReductionModeCreateInfo *val)

25
{

26
    size_t size = 0;

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

28
    size += vn_sizeof_VkSamplerReductionMode(&val->reductionMode);

29
    return size;

30
}

31


32
static inline size_t

33
vn_sizeof_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *val)

34
{

35
    size_t size = 0;

36


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

38
    size += vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(val->pNext);

39
    size += vn_sizeof_VkSamplerReductionModeCreateInfo_self(val);

40


41
    return size;

42
}

43


44
static inline void

45
vn_encode_VkSamplerReductionModeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)

46
{

47
    /* no known/supported struct */

48
    vn_encode_simple_pointer(enc, NULL);

49
}

50


51
static inline void

52
vn_encode_VkSamplerReductionModeCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)

53
{

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

55
    vn_encode_VkSamplerReductionMode(enc, &val->reductionMode);

56
}

57


58
static inline void

59
vn_encode_VkSamplerReductionModeCreateInfo(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)

60
{

61
    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO);

62
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO });

63
    vn_encode_VkSamplerReductionModeCreateInfo_pnext(enc, val->pNext);

64
    vn_encode_VkSamplerReductionModeCreateInfo_self(enc, val);

65
}

66


67
/* struct VkSamplerCreateInfo chain */

68


69
static inline size_t

70
vn_sizeof_VkSamplerCreateInfo_pnext(const void *val)

71
{

72
    const VkBaseInStructure *pnext = val;

73
    size_t size = 0;

74


75
    while (pnext) {

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

77
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:

78
            size += vn_sizeof_simple_pointer(pnext);

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

80
            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);

81
            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);

82
            return size;

83
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:

84
            size += vn_sizeof_simple_pointer(pnext);

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

86
            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);

87
            size += vn_sizeof_VkSamplerReductionModeCreateInfo_self((const VkSamplerReductionModeCreateInfo *)pnext);

88
            return size;

89
        default:

90
            /* ignore unknown/unsupported struct */

91
            break;

92
        }

93
        pnext = pnext->pNext;

94
    }

95


96
    return vn_sizeof_simple_pointer(NULL);

97
}

98


99
static inline size_t

100
vn_sizeof_VkSamplerCreateInfo_self(const VkSamplerCreateInfo *val)

101
{

102
    size_t size = 0;

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

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

105
    size += vn_sizeof_VkFilter(&val->magFilter);

106
    size += vn_sizeof_VkFilter(&val->minFilter);

107
    size += vn_sizeof_VkSamplerMipmapMode(&val->mipmapMode);

108
    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeU);

109
    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeV);

110
    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeW);

111
    size += vn_sizeof_float(&val->mipLodBias);

112
    size += vn_sizeof_VkBool32(&val->anisotropyEnable);

113
    size += vn_sizeof_float(&val->maxAnisotropy);

114
    size += vn_sizeof_VkBool32(&val->compareEnable);

115
    size += vn_sizeof_VkCompareOp(&val->compareOp);

116
    size += vn_sizeof_float(&val->minLod);

117
    size += vn_sizeof_float(&val->maxLod);

118
    size += vn_sizeof_VkBorderColor(&val->borderColor);

119
    size += vn_sizeof_VkBool32(&val->unnormalizedCoordinates);

120
    return size;

121
}

122


123
static inline size_t

124
vn_sizeof_VkSamplerCreateInfo(const VkSamplerCreateInfo *val)

125
{

126
    size_t size = 0;

127


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

129
    size += vn_sizeof_VkSamplerCreateInfo_pnext(val->pNext);

130
    size += vn_sizeof_VkSamplerCreateInfo_self(val);

131


132
    return size;

133
}

134


135
static inline void

136
vn_encode_VkSamplerCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)

137
{

138
    const VkBaseInStructure *pnext = val;

139


140
    while (pnext) {

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

142
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:

143
            vn_encode_simple_pointer(enc, pnext);

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

145
            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);

146
            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);

147
            return;

148
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:

149
            vn_encode_simple_pointer(enc, pnext);

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

151
            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);

152
            vn_encode_VkSamplerReductionModeCreateInfo_self(enc, (const VkSamplerReductionModeCreateInfo *)pnext);

153
            return;

154
        default:

155
            /* ignore unknown/unsupported struct */

156
            break;

157
        }

158
        pnext = pnext->pNext;

159
    }

160


161
    vn_encode_simple_pointer(enc, NULL);

162
}

163


164
static inline void

165
vn_encode_VkSamplerCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)

166
{

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

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

169
    vn_encode_VkFilter(enc, &val->magFilter);

170
    vn_encode_VkFilter(enc, &val->minFilter);

171
    vn_encode_VkSamplerMipmapMode(enc, &val->mipmapMode);

172
    vn_encode_VkSamplerAddressMode(enc, &val->addressModeU);

173
    vn_encode_VkSamplerAddressMode(enc, &val->addressModeV);

174
    vn_encode_VkSamplerAddressMode(enc, &val->addressModeW);

175
    vn_encode_float(enc, &val->mipLodBias);

176
    vn_encode_VkBool32(enc, &val->anisotropyEnable);

177
    vn_encode_float(enc, &val->maxAnisotropy);

178
    vn_encode_VkBool32(enc, &val->compareEnable);

179
    vn_encode_VkCompareOp(enc, &val->compareOp);

180
    vn_encode_float(enc, &val->minLod);

181
    vn_encode_float(enc, &val->maxLod);

182
    vn_encode_VkBorderColor(enc, &val->borderColor);

183
    vn_encode_VkBool32(enc, &val->unnormalizedCoordinates);

184
}

185


186
static inline void

187
vn_encode_VkSamplerCreateInfo(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)

188
{

189
    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);

190
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO });

191
    vn_encode_VkSamplerCreateInfo_pnext(enc, val->pNext);

192
    vn_encode_VkSamplerCreateInfo_self(enc, val);

193
}

194


195
static inline size_t vn_sizeof_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)

196
{

197
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;

198
    const VkFlags cmd_flags = 0;

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

200


201
    cmd_size += vn_sizeof_VkDevice(&device);

202
    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);

203
    if (pCreateInfo)

204
        cmd_size += vn_sizeof_VkSamplerCreateInfo(pCreateInfo);

205
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

206
    if (pAllocator)

207
        assert(false);

208
    cmd_size += vn_sizeof_simple_pointer(pSampler);

209
    if (pSampler)

210
        cmd_size += vn_sizeof_VkSampler(pSampler);

211


212
    return cmd_size;

213
}

214


215
static inline void vn_encode_vkCreateSampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)

216
{

217
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;

218


219
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

220
    vn_encode_VkFlags(enc, &cmd_flags);

221


222
    vn_encode_VkDevice(enc, &device);

223
    if (vn_encode_simple_pointer(enc, pCreateInfo))

224
        vn_encode_VkSamplerCreateInfo(enc, pCreateInfo);

225
    if (vn_encode_simple_pointer(enc, pAllocator))

226
        assert(false);

227
    if (vn_encode_simple_pointer(enc, pSampler))

228
        vn_encode_VkSampler(enc, pSampler);

229
}

230


231
static inline size_t vn_sizeof_vkCreateSampler_reply(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)

232
{

233
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;

234
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

235


236
    VkResult ret;

237
    cmd_size += vn_sizeof_VkResult(&ret);

238
    /* skip device */

239
    /* skip pCreateInfo */

240
    /* skip pAllocator */

241
    cmd_size += vn_sizeof_simple_pointer(pSampler);

242
    if (pSampler)

243
        cmd_size += vn_sizeof_VkSampler(pSampler);

244


245
    return cmd_size;

246
}

247


248
static inline VkResult vn_decode_vkCreateSampler_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)

249
{

250
    VkCommandTypeEXT command_type;

251
    vn_decode_VkCommandTypeEXT(dec, &command_type);

252
    assert(command_type == VK_COMMAND_TYPE_vkCreateSampler_EXT);

253


254
    VkResult ret;

255
    vn_decode_VkResult(dec, &ret);

256
    /* skip device */

257
    /* skip pCreateInfo */

258
    /* skip pAllocator */

259
    if (vn_decode_simple_pointer(dec)) {

260
        vn_decode_VkSampler(dec, pSampler);

261
    } else {

262
        pSampler = NULL;

263
    }

264


265
    return ret;

266
}

267


268
static inline size_t vn_sizeof_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)

269
{

270
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;

271
    const VkFlags cmd_flags = 0;

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

273


274
    cmd_size += vn_sizeof_VkDevice(&device);

275
    cmd_size += vn_sizeof_VkSampler(&sampler);

276
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

277
    if (pAllocator)

278
        assert(false);

279


280
    return cmd_size;

281
}

282


283
static inline void vn_encode_vkDestroySampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)

284
{

285
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;

286


287
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

288
    vn_encode_VkFlags(enc, &cmd_flags);

289


290
    vn_encode_VkDevice(enc, &device);

291
    vn_encode_VkSampler(enc, &sampler);

292
    if (vn_encode_simple_pointer(enc, pAllocator))

293
        assert(false);

294
}

295


296
static inline size_t vn_sizeof_vkDestroySampler_reply(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)

297
{

298
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;

299
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

300


301
    /* skip device */

302
    /* skip sampler */

303
    /* skip pAllocator */

304


305
    return cmd_size;

306
}

307


308
static inline void vn_decode_vkDestroySampler_reply(struct vn_cs_decoder *dec, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)

309
{

310
    VkCommandTypeEXT command_type;

311
    vn_decode_VkCommandTypeEXT(dec, &command_type);

312
    assert(command_type == VK_COMMAND_TYPE_vkDestroySampler_EXT);

313


314
    /* skip device */

315
    /* skip sampler */

316
    /* skip pAllocator */

317
}

318


319
static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, struct vn_instance_submit_command *submit)

320
{

321
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

322
    void *cmd_data = local_cmd_data;

323
    size_t cmd_size = vn_sizeof_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);

324
    if (cmd_size > sizeof(local_cmd_data)) {

325
        cmd_data = malloc(cmd_size);

326
        if (!cmd_data)

327
            cmd_size = 0;

328
    }

329
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;

330


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

332
    if (cmd_size) {

333
        vn_encode_vkCreateSampler(enc, cmd_flags, device, pCreateInfo, pAllocator, pSampler);

334
        vn_instance_submit_command(vn_instance, submit);

335
        if (cmd_data != local_cmd_data)

336
            free(cmd_data);

337
    }

338
}

339


340
static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)

341
{

342
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

343
    void *cmd_data = local_cmd_data;

344
    size_t cmd_size = vn_sizeof_vkDestroySampler(device, sampler, pAllocator);

345
    if (cmd_size > sizeof(local_cmd_data)) {

346
        cmd_data = malloc(cmd_size);

347
        if (!cmd_data)

348
            cmd_size = 0;

349
    }

350
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;

351


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

353
    if (cmd_size) {

354
        vn_encode_vkDestroySampler(enc, cmd_flags, device, sampler, pAllocator);

355
        vn_instance_submit_command(vn_instance, submit);

356
        if (cmd_data != local_cmd_data)

357
            free(cmd_data);

358
    }

359
}

360


361
static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)

362
{

363
    struct vn_instance_submit_command submit;

364
    vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit);

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

366
    if (dec) {

367
        const VkResult ret = vn_decode_vkCreateSampler_reply(dec, device, pCreateInfo, pAllocator, pSampler);

368
        vn_instance_free_command_reply(vn_instance, &submit);

369
        return ret;

370
    } else {

371
        return VK_ERROR_OUT_OF_HOST_MEMORY;

372
    }

373
}

374


375
static inline void vn_async_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)

376
{

377
    struct vn_instance_submit_command submit;

378
    vn_submit_vkCreateSampler(vn_instance, 0, device, pCreateInfo, pAllocator, pSampler, &submit);

379
}

380


381
static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)

382
{

383
    struct vn_instance_submit_command submit;

384
    vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit);

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

386
    if (dec) {

387
        vn_decode_vkDestroySampler_reply(dec, device, sampler, pAllocator);

388
        vn_instance_free_command_reply(vn_instance, &submit);

389
    }

390
}

391


392
static inline void vn_async_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)

393
{

394
    struct vn_instance_submit_command submit;

395
    vn_submit_vkDestroySampler(vn_instance, 0, device, sampler, pAllocator, &submit);

396
}

397


398
#endif /* VN_PROTOCOL_DRIVER_SAMPLER_H */

399


400