diff --git a/src/virtio/venus-protocol/vn_protocol_driver.h b/src/virtio/venus-protocol/vn_protocol_driver.h index 640dbd99907..29a4ae3f578 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver.h +++ b/src/virtio/venus-protocol/vn_protocol_driver.h @@ -1,4 +1,4 @@ -/* This file is generated by venus-protocol git-825670b9. */ +/* This file is generated by venus-protocol git-0048ccc3. */ /* * Copyright 2020 Google LLC @@ -41,5 +41,6 @@ #include "vn_protocol_driver_pipeline_cache.h" #include "vn_protocol_driver_command_pool.h" #include "vn_protocol_driver_command_buffer.h" +#include "vn_protocol_driver_private_data_slot.h" #endif /* VN_PROTOCOL_DRIVER_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_buffer.h b/src/virtio/venus-protocol/vn_protocol_driver_buffer.h index b09781cb4ba..58a1e29257d 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_buffer.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_buffer.h @@ -64,6 +64,33 @@ vn_encode_VkExternalMemoryBufferCreateInfo(struct vn_cs_encoder *enc, const VkEx vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, val); } +static inline void +vn_decode_VkExternalMemoryBufferCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkExternalMemoryBufferCreateInfo_self(struct vn_cs_decoder *dec, VkExternalMemoryBufferCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->handleTypes); +} + +static inline void +vn_decode_VkExternalMemoryBufferCreateInfo(struct vn_cs_decoder *dec, VkExternalMemoryBufferCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkExternalMemoryBufferCreateInfo_pnext(dec, val->pNext); + vn_decode_VkExternalMemoryBufferCreateInfo_self(dec, val); +} + /* struct VkBufferOpaqueCaptureAddressCreateInfo chain */ static inline size_t @@ -117,6 +144,33 @@ vn_encode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_encoder *enc, cons vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, val); } +static inline void +vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_self(struct vn_cs_decoder *dec, VkBufferOpaqueCaptureAddressCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint64_t(dec, &val->opaqueCaptureAddress); +} + +static inline void +vn_decode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_decoder *dec, VkBufferOpaqueCaptureAddressCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(dec, val->pNext); + vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_self(dec, val); +} + /* struct VkBufferCreateInfo chain */ static inline size_t @@ -235,6 +289,67 @@ vn_encode_VkBufferCreateInfo(struct vn_cs_encoder *enc, const VkBufferCreateInfo vn_encode_VkBufferCreateInfo_self(enc, val); } +static inline void +vn_decode_VkBufferCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + vn_decode_VkBufferCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkExternalMemoryBufferCreateInfo_self(dec, (VkExternalMemoryBufferCreateInfo *)pnext); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + vn_decode_VkBufferCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_self(dec, (VkBufferOpaqueCaptureAddressCreateInfo *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkBufferCreateInfo_self(struct vn_cs_decoder *dec, VkBufferCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->flags); + vn_decode_VkDeviceSize(dec, &val->size); + vn_decode_VkFlags(dec, &val->usage); + vn_decode_VkSharingMode(dec, &val->sharingMode); + vn_decode_uint32_t(dec, &val->queueFamilyIndexCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->queueFamilyIndexCount); + vn_decode_uint32_t_array(dec, (uint32_t *)val->pQueueFamilyIndices, array_size); + } else { + vn_decode_array_size_unchecked(dec); + val->pQueueFamilyIndices = NULL; + } +} + +static inline void +vn_decode_VkBufferCreateInfo(struct vn_cs_decoder *dec, VkBufferCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkBufferCreateInfo_pnext(dec, val->pNext); + vn_decode_VkBufferCreateInfo_self(dec, val); +} + /* struct VkBindBufferMemoryDeviceGroupInfo chain */ static inline size_t @@ -525,6 +640,62 @@ vn_encode_VkBufferMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkBuf vn_encode_VkBufferMemoryRequirementsInfo2_self(enc, val); } +/* struct VkDeviceBufferMemoryRequirements chain */ + +static inline size_t +vn_sizeof_VkDeviceBufferMemoryRequirements_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceBufferMemoryRequirements_self(const VkDeviceBufferMemoryRequirements *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_simple_pointer(val->pCreateInfo); + if (val->pCreateInfo) + size += vn_sizeof_VkBufferCreateInfo(val->pCreateInfo); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceBufferMemoryRequirements_pnext(val->pNext); + size += vn_sizeof_VkDeviceBufferMemoryRequirements_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceBufferMemoryRequirements_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceBufferMemoryRequirements_self(struct vn_cs_encoder *enc, const VkDeviceBufferMemoryRequirements *val) +{ + /* skip val->{sType,pNext} */ + if (vn_encode_simple_pointer(enc, val->pCreateInfo)) + vn_encode_VkBufferCreateInfo(enc, val->pCreateInfo); +} + +static inline void +vn_encode_VkDeviceBufferMemoryRequirements(struct vn_cs_encoder *enc, const VkDeviceBufferMemoryRequirements *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS }); + vn_encode_VkDeviceBufferMemoryRequirements_pnext(enc, val->pNext); + vn_encode_VkDeviceBufferMemoryRequirements_self(enc, val); +} + /* struct VkBufferDeviceAddressInfo chain */ static inline size_t @@ -970,6 +1141,66 @@ static inline void vn_decode_vkGetBufferMemoryRequirements2_reply(struct vn_cs_d } } +static inline size_t vn_sizeof_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkDeviceBufferMemoryRequirements(pInfo); + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceBufferMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkDeviceBufferMemoryRequirements(enc, pInfo); + if (vn_encode_simple_pointer(enc, pMemoryRequirements)) + vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements); +} + +static inline size_t vn_sizeof_vkGetDeviceBufferMemoryRequirements_reply(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pInfo */ + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceBufferMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT); + + /* skip device */ + /* skip pInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements); + } else { + pMemoryRequirements = NULL; + } +} + static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT; @@ -1202,6 +1433,27 @@ static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance * } } +static inline void vn_submit_vkGetDeviceBufferMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceBufferMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkGetDeviceBufferMemoryRequirements(enc, cmd_flags, device, pInfo, pMemoryRequirements); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + static inline void vn_submit_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit) { uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; @@ -1367,6 +1619,25 @@ static inline void vn_async_vkGetBufferMemoryRequirements2(struct vn_instance *v vn_submit_vkGetBufferMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit); } +static inline void vn_call_vkGetDeviceBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceBufferMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkGetDeviceBufferMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkGetDeviceBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceBufferMemoryRequirements(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit); +} + static inline uint64_t vn_call_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { VN_TRACE_FUNC(); diff --git a/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h b/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h index e89beb62ee9..6e86b693c93 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h @@ -68,12 +68,143 @@ vn_encode_VkCommandBufferAllocateInfo(struct vn_cs_encoder *enc, const VkCommand vn_encode_VkCommandBufferAllocateInfo_self(enc, val); } +/* struct VkCommandBufferInheritanceRenderingInfo chain */ + +static inline size_t +vn_sizeof_VkCommandBufferInheritanceRenderingInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCommandBufferInheritanceRenderingInfo_self(const VkCommandBufferInheritanceRenderingInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->viewMask); + size += vn_sizeof_uint32_t(&val->colorAttachmentCount); + if (val->pColorAttachmentFormats) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + size += vn_sizeof_VkFormat_array(val->pColorAttachmentFormats, val->colorAttachmentCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_VkFormat(&val->depthAttachmentFormat); + size += vn_sizeof_VkFormat(&val->stencilAttachmentFormat); + size += vn_sizeof_VkSampleCountFlagBits(&val->rasterizationSamples); + return size; +} + +static inline size_t +vn_sizeof_VkCommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCommandBufferInheritanceRenderingInfo_pnext(val->pNext); + size += vn_sizeof_VkCommandBufferInheritanceRenderingInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkCommandBufferInheritanceRenderingInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCommandBufferInheritanceRenderingInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceRenderingInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->viewMask); + vn_encode_uint32_t(enc, &val->colorAttachmentCount); + if (val->pColorAttachmentFormats) { + vn_encode_array_size(enc, val->colorAttachmentCount); + vn_encode_VkFormat_array(enc, val->pColorAttachmentFormats, val->colorAttachmentCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFormat(enc, &val->depthAttachmentFormat); + vn_encode_VkFormat(enc, &val->stencilAttachmentFormat); + vn_encode_VkSampleCountFlagBits(enc, &val->rasterizationSamples); +} + +static inline void +vn_encode_VkCommandBufferInheritanceRenderingInfo(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceRenderingInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO }); + vn_encode_VkCommandBufferInheritanceRenderingInfo_pnext(enc, val->pNext); + vn_encode_VkCommandBufferInheritanceRenderingInfo_self(enc, val); +} + +static inline void +vn_decode_VkCommandBufferInheritanceRenderingInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkCommandBufferInheritanceRenderingInfo_self(struct vn_cs_decoder *dec, VkCommandBufferInheritanceRenderingInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->flags); + vn_decode_uint32_t(dec, &val->viewMask); + vn_decode_uint32_t(dec, &val->colorAttachmentCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->colorAttachmentCount); + vn_decode_VkFormat_array(dec, (VkFormat *)val->pColorAttachmentFormats, array_size); + } else { + vn_decode_array_size_unchecked(dec); + val->pColorAttachmentFormats = NULL; + } + vn_decode_VkFormat(dec, &val->depthAttachmentFormat); + vn_decode_VkFormat(dec, &val->stencilAttachmentFormat); + vn_decode_VkSampleCountFlagBits(dec, &val->rasterizationSamples); +} + +static inline void +vn_decode_VkCommandBufferInheritanceRenderingInfo(struct vn_cs_decoder *dec, VkCommandBufferInheritanceRenderingInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO); + + assert(val->sType == stype); + vn_decode_VkCommandBufferInheritanceRenderingInfo_pnext(dec, val->pNext); + vn_decode_VkCommandBufferInheritanceRenderingInfo_self(dec, val); +} + /* struct VkCommandBufferInheritanceInfo chain */ static inline size_t vn_sizeof_VkCommandBufferInheritanceInfo_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkCommandBufferInheritanceInfo_pnext(pnext->pNext); + size += vn_sizeof_VkCommandBufferInheritanceRenderingInfo_self((const VkCommandBufferInheritanceRenderingInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -106,7 +237,23 @@ vn_sizeof_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo *v static inline void vn_encode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkCommandBufferInheritanceInfo_pnext(enc, pnext->pNext); + vn_encode_VkCommandBufferInheritanceRenderingInfo_self(enc, (const VkCommandBufferInheritanceRenderingInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } @@ -134,9 +281,28 @@ vn_encode_VkCommandBufferInheritanceInfo(struct vn_cs_encoder *enc, const VkComm static inline void vn_decode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_decoder *dec, const void *val) { - /* no known/supported struct */ - if (vn_decode_simple_pointer(dec)) + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + vn_decode_VkCommandBufferInheritanceInfo_pnext(dec, pnext->pNext); + vn_decode_VkCommandBufferInheritanceRenderingInfo_self(dec, (VkCommandBufferInheritanceRenderingInfo *)pnext); + break; + default: assert(false); + break; + } } static inline void @@ -1244,6 +1410,1185 @@ vn_encode_VkSubpassEndInfo(struct vn_cs_encoder *enc, const VkSubpassEndInfo *va vn_encode_VkSubpassEndInfo_self(enc, val); } +/* struct VkBufferCopy2 chain */ + +static inline size_t +vn_sizeof_VkBufferCopy2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferCopy2_self(const VkBufferCopy2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceSize(&val->srcOffset); + size += vn_sizeof_VkDeviceSize(&val->dstOffset); + size += vn_sizeof_VkDeviceSize(&val->size); + return size; +} + +static inline size_t +vn_sizeof_VkBufferCopy2(const VkBufferCopy2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferCopy2_pnext(val->pNext); + size += vn_sizeof_VkBufferCopy2_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferCopy2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferCopy2_self(struct vn_cs_encoder *enc, const VkBufferCopy2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDeviceSize(enc, &val->srcOffset); + vn_encode_VkDeviceSize(enc, &val->dstOffset); + vn_encode_VkDeviceSize(enc, &val->size); +} + +static inline void +vn_encode_VkBufferCopy2(struct vn_cs_encoder *enc, const VkBufferCopy2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_COPY_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_COPY_2 }); + vn_encode_VkBufferCopy2_pnext(enc, val->pNext); + vn_encode_VkBufferCopy2_self(enc, val); +} + +/* struct VkCopyBufferInfo2 chain */ + +static inline size_t +vn_sizeof_VkCopyBufferInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCopyBufferInfo2_self(const VkCopyBufferInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBuffer(&val->srcBuffer); + size += vn_sizeof_VkBuffer(&val->dstBuffer); + size += vn_sizeof_uint32_t(&val->regionCount); + if (val->pRegions) { + size += vn_sizeof_array_size(val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + size += vn_sizeof_VkBufferCopy2(&val->pRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkCopyBufferInfo2(const VkCopyBufferInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCopyBufferInfo2_pnext(val->pNext); + size += vn_sizeof_VkCopyBufferInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkCopyBufferInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCopyBufferInfo2_self(struct vn_cs_encoder *enc, const VkCopyBufferInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBuffer(enc, &val->srcBuffer); + vn_encode_VkBuffer(enc, &val->dstBuffer); + vn_encode_uint32_t(enc, &val->regionCount); + if (val->pRegions) { + vn_encode_array_size(enc, val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + vn_encode_VkBufferCopy2(enc, &val->pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkCopyBufferInfo2(struct vn_cs_encoder *enc, const VkCopyBufferInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 }); + vn_encode_VkCopyBufferInfo2_pnext(enc, val->pNext); + vn_encode_VkCopyBufferInfo2_self(enc, val); +} + +/* struct VkImageCopy2 chain */ + +static inline size_t +vn_sizeof_VkImageCopy2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageCopy2_self(const VkImageCopy2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource); + size += vn_sizeof_VkOffset3D(&val->srcOffset); + size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource); + size += vn_sizeof_VkOffset3D(&val->dstOffset); + size += vn_sizeof_VkExtent3D(&val->extent); + return size; +} + +static inline size_t +vn_sizeof_VkImageCopy2(const VkImageCopy2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageCopy2_pnext(val->pNext); + size += vn_sizeof_VkImageCopy2_self(val); + + return size; +} + +static inline void +vn_encode_VkImageCopy2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageCopy2_self(struct vn_cs_encoder *enc, const VkImageCopy2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource); + vn_encode_VkOffset3D(enc, &val->srcOffset); + vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource); + vn_encode_VkOffset3D(enc, &val->dstOffset); + vn_encode_VkExtent3D(enc, &val->extent); +} + +static inline void +vn_encode_VkImageCopy2(struct vn_cs_encoder *enc, const VkImageCopy2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_COPY_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_COPY_2 }); + vn_encode_VkImageCopy2_pnext(enc, val->pNext); + vn_encode_VkImageCopy2_self(enc, val); +} + +/* struct VkCopyImageInfo2 chain */ + +static inline size_t +vn_sizeof_VkCopyImageInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCopyImageInfo2_self(const VkCopyImageInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->srcImage); + size += vn_sizeof_VkImageLayout(&val->srcImageLayout); + size += vn_sizeof_VkImage(&val->dstImage); + size += vn_sizeof_VkImageLayout(&val->dstImageLayout); + size += vn_sizeof_uint32_t(&val->regionCount); + if (val->pRegions) { + size += vn_sizeof_array_size(val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + size += vn_sizeof_VkImageCopy2(&val->pRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkCopyImageInfo2(const VkCopyImageInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCopyImageInfo2_pnext(val->pNext); + size += vn_sizeof_VkCopyImageInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkCopyImageInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCopyImageInfo2_self(struct vn_cs_encoder *enc, const VkCopyImageInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->srcImage); + vn_encode_VkImageLayout(enc, &val->srcImageLayout); + vn_encode_VkImage(enc, &val->dstImage); + vn_encode_VkImageLayout(enc, &val->dstImageLayout); + vn_encode_uint32_t(enc, &val->regionCount); + if (val->pRegions) { + vn_encode_array_size(enc, val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + vn_encode_VkImageCopy2(enc, &val->pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkCopyImageInfo2(struct vn_cs_encoder *enc, const VkCopyImageInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 }); + vn_encode_VkCopyImageInfo2_pnext(enc, val->pNext); + vn_encode_VkCopyImageInfo2_self(enc, val); +} + +/* struct VkImageBlit2 chain */ + +static inline size_t +vn_sizeof_VkImageBlit2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageBlit2_self(const VkImageBlit2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource); + size += vn_sizeof_array_size(2); + for (uint32_t i = 0; i < 2; i++) + size += vn_sizeof_VkOffset3D(&val->srcOffsets[i]); + size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource); + size += vn_sizeof_array_size(2); + for (uint32_t i = 0; i < 2; i++) + size += vn_sizeof_VkOffset3D(&val->dstOffsets[i]); + return size; +} + +static inline size_t +vn_sizeof_VkImageBlit2(const VkImageBlit2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageBlit2_pnext(val->pNext); + size += vn_sizeof_VkImageBlit2_self(val); + + return size; +} + +static inline void +vn_encode_VkImageBlit2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageBlit2_self(struct vn_cs_encoder *enc, const VkImageBlit2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource); + vn_encode_array_size(enc, 2); + for (uint32_t i = 0; i < 2; i++) + vn_encode_VkOffset3D(enc, &val->srcOffsets[i]); + vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource); + vn_encode_array_size(enc, 2); + for (uint32_t i = 0; i < 2; i++) + vn_encode_VkOffset3D(enc, &val->dstOffsets[i]); +} + +static inline void +vn_encode_VkImageBlit2(struct vn_cs_encoder *enc, const VkImageBlit2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_BLIT_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_BLIT_2 }); + vn_encode_VkImageBlit2_pnext(enc, val->pNext); + vn_encode_VkImageBlit2_self(enc, val); +} + +/* struct VkBlitImageInfo2 chain */ + +static inline size_t +vn_sizeof_VkBlitImageInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBlitImageInfo2_self(const VkBlitImageInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->srcImage); + size += vn_sizeof_VkImageLayout(&val->srcImageLayout); + size += vn_sizeof_VkImage(&val->dstImage); + size += vn_sizeof_VkImageLayout(&val->dstImageLayout); + size += vn_sizeof_uint32_t(&val->regionCount); + if (val->pRegions) { + size += vn_sizeof_array_size(val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + size += vn_sizeof_VkImageBlit2(&val->pRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_VkFilter(&val->filter); + return size; +} + +static inline size_t +vn_sizeof_VkBlitImageInfo2(const VkBlitImageInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBlitImageInfo2_pnext(val->pNext); + size += vn_sizeof_VkBlitImageInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkBlitImageInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBlitImageInfo2_self(struct vn_cs_encoder *enc, const VkBlitImageInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->srcImage); + vn_encode_VkImageLayout(enc, &val->srcImageLayout); + vn_encode_VkImage(enc, &val->dstImage); + vn_encode_VkImageLayout(enc, &val->dstImageLayout); + vn_encode_uint32_t(enc, &val->regionCount); + if (val->pRegions) { + vn_encode_array_size(enc, val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + vn_encode_VkImageBlit2(enc, &val->pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFilter(enc, &val->filter); +} + +static inline void +vn_encode_VkBlitImageInfo2(struct vn_cs_encoder *enc, const VkBlitImageInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 }); + vn_encode_VkBlitImageInfo2_pnext(enc, val->pNext); + vn_encode_VkBlitImageInfo2_self(enc, val); +} + +/* struct VkBufferImageCopy2 chain */ + +static inline size_t +vn_sizeof_VkBufferImageCopy2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferImageCopy2_self(const VkBufferImageCopy2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceSize(&val->bufferOffset); + size += vn_sizeof_uint32_t(&val->bufferRowLength); + size += vn_sizeof_uint32_t(&val->bufferImageHeight); + size += vn_sizeof_VkImageSubresourceLayers(&val->imageSubresource); + size += vn_sizeof_VkOffset3D(&val->imageOffset); + size += vn_sizeof_VkExtent3D(&val->imageExtent); + return size; +} + +static inline size_t +vn_sizeof_VkBufferImageCopy2(const VkBufferImageCopy2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferImageCopy2_pnext(val->pNext); + size += vn_sizeof_VkBufferImageCopy2_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferImageCopy2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferImageCopy2_self(struct vn_cs_encoder *enc, const VkBufferImageCopy2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDeviceSize(enc, &val->bufferOffset); + vn_encode_uint32_t(enc, &val->bufferRowLength); + vn_encode_uint32_t(enc, &val->bufferImageHeight); + vn_encode_VkImageSubresourceLayers(enc, &val->imageSubresource); + vn_encode_VkOffset3D(enc, &val->imageOffset); + vn_encode_VkExtent3D(enc, &val->imageExtent); +} + +static inline void +vn_encode_VkBufferImageCopy2(struct vn_cs_encoder *enc, const VkBufferImageCopy2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 }); + vn_encode_VkBufferImageCopy2_pnext(enc, val->pNext); + vn_encode_VkBufferImageCopy2_self(enc, val); +} + +/* struct VkCopyBufferToImageInfo2 chain */ + +static inline size_t +vn_sizeof_VkCopyBufferToImageInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCopyBufferToImageInfo2_self(const VkCopyBufferToImageInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBuffer(&val->srcBuffer); + size += vn_sizeof_VkImage(&val->dstImage); + size += vn_sizeof_VkImageLayout(&val->dstImageLayout); + size += vn_sizeof_uint32_t(&val->regionCount); + if (val->pRegions) { + size += vn_sizeof_array_size(val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + size += vn_sizeof_VkBufferImageCopy2(&val->pRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCopyBufferToImageInfo2_pnext(val->pNext); + size += vn_sizeof_VkCopyBufferToImageInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkCopyBufferToImageInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCopyBufferToImageInfo2_self(struct vn_cs_encoder *enc, const VkCopyBufferToImageInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBuffer(enc, &val->srcBuffer); + vn_encode_VkImage(enc, &val->dstImage); + vn_encode_VkImageLayout(enc, &val->dstImageLayout); + vn_encode_uint32_t(enc, &val->regionCount); + if (val->pRegions) { + vn_encode_array_size(enc, val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + vn_encode_VkBufferImageCopy2(enc, &val->pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkCopyBufferToImageInfo2(struct vn_cs_encoder *enc, const VkCopyBufferToImageInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 }); + vn_encode_VkCopyBufferToImageInfo2_pnext(enc, val->pNext); + vn_encode_VkCopyBufferToImageInfo2_self(enc, val); +} + +/* struct VkCopyImageToBufferInfo2 chain */ + +static inline size_t +vn_sizeof_VkCopyImageToBufferInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCopyImageToBufferInfo2_self(const VkCopyImageToBufferInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->srcImage); + size += vn_sizeof_VkImageLayout(&val->srcImageLayout); + size += vn_sizeof_VkBuffer(&val->dstBuffer); + size += vn_sizeof_uint32_t(&val->regionCount); + if (val->pRegions) { + size += vn_sizeof_array_size(val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + size += vn_sizeof_VkBufferImageCopy2(&val->pRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCopyImageToBufferInfo2_pnext(val->pNext); + size += vn_sizeof_VkCopyImageToBufferInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkCopyImageToBufferInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCopyImageToBufferInfo2_self(struct vn_cs_encoder *enc, const VkCopyImageToBufferInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->srcImage); + vn_encode_VkImageLayout(enc, &val->srcImageLayout); + vn_encode_VkBuffer(enc, &val->dstBuffer); + vn_encode_uint32_t(enc, &val->regionCount); + if (val->pRegions) { + vn_encode_array_size(enc, val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + vn_encode_VkBufferImageCopy2(enc, &val->pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkCopyImageToBufferInfo2(struct vn_cs_encoder *enc, const VkCopyImageToBufferInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 }); + vn_encode_VkCopyImageToBufferInfo2_pnext(enc, val->pNext); + vn_encode_VkCopyImageToBufferInfo2_self(enc, val); +} + +/* struct VkImageResolve2 chain */ + +static inline size_t +vn_sizeof_VkImageResolve2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageResolve2_self(const VkImageResolve2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource); + size += vn_sizeof_VkOffset3D(&val->srcOffset); + size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource); + size += vn_sizeof_VkOffset3D(&val->dstOffset); + size += vn_sizeof_VkExtent3D(&val->extent); + return size; +} + +static inline size_t +vn_sizeof_VkImageResolve2(const VkImageResolve2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageResolve2_pnext(val->pNext); + size += vn_sizeof_VkImageResolve2_self(val); + + return size; +} + +static inline void +vn_encode_VkImageResolve2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageResolve2_self(struct vn_cs_encoder *enc, const VkImageResolve2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource); + vn_encode_VkOffset3D(enc, &val->srcOffset); + vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource); + vn_encode_VkOffset3D(enc, &val->dstOffset); + vn_encode_VkExtent3D(enc, &val->extent); +} + +static inline void +vn_encode_VkImageResolve2(struct vn_cs_encoder *enc, const VkImageResolve2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 }); + vn_encode_VkImageResolve2_pnext(enc, val->pNext); + vn_encode_VkImageResolve2_self(enc, val); +} + +/* struct VkResolveImageInfo2 chain */ + +static inline size_t +vn_sizeof_VkResolveImageInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkResolveImageInfo2_self(const VkResolveImageInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->srcImage); + size += vn_sizeof_VkImageLayout(&val->srcImageLayout); + size += vn_sizeof_VkImage(&val->dstImage); + size += vn_sizeof_VkImageLayout(&val->dstImageLayout); + size += vn_sizeof_uint32_t(&val->regionCount); + if (val->pRegions) { + size += vn_sizeof_array_size(val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + size += vn_sizeof_VkImageResolve2(&val->pRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkResolveImageInfo2(const VkResolveImageInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkResolveImageInfo2_pnext(val->pNext); + size += vn_sizeof_VkResolveImageInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkResolveImageInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkResolveImageInfo2_self(struct vn_cs_encoder *enc, const VkResolveImageInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->srcImage); + vn_encode_VkImageLayout(enc, &val->srcImageLayout); + vn_encode_VkImage(enc, &val->dstImage); + vn_encode_VkImageLayout(enc, &val->dstImageLayout); + vn_encode_uint32_t(enc, &val->regionCount); + if (val->pRegions) { + vn_encode_array_size(enc, val->regionCount); + for (uint32_t i = 0; i < val->regionCount; i++) + vn_encode_VkImageResolve2(enc, &val->pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkResolveImageInfo2(struct vn_cs_encoder *enc, const VkResolveImageInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 }); + vn_encode_VkResolveImageInfo2_pnext(enc, val->pNext); + vn_encode_VkResolveImageInfo2_self(enc, val); +} + +/* struct VkBufferMemoryBarrier2 chain */ + +static inline size_t +vn_sizeof_VkBufferMemoryBarrier2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferMemoryBarrier2_self(const VkBufferMemoryBarrier2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags64(&val->srcStageMask); + size += vn_sizeof_VkFlags64(&val->srcAccessMask); + size += vn_sizeof_VkFlags64(&val->dstStageMask); + size += vn_sizeof_VkFlags64(&val->dstAccessMask); + size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex); + size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex); + size += vn_sizeof_VkBuffer(&val->buffer); + size += vn_sizeof_VkDeviceSize(&val->offset); + size += vn_sizeof_VkDeviceSize(&val->size); + return size; +} + +static inline size_t +vn_sizeof_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferMemoryBarrier2_pnext(val->pNext); + size += vn_sizeof_VkBufferMemoryBarrier2_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferMemoryBarrier2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferMemoryBarrier2_self(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags64(enc, &val->srcStageMask); + vn_encode_VkFlags64(enc, &val->srcAccessMask); + vn_encode_VkFlags64(enc, &val->dstStageMask); + vn_encode_VkFlags64(enc, &val->dstAccessMask); + vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex); + vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex); + vn_encode_VkBuffer(enc, &val->buffer); + vn_encode_VkDeviceSize(enc, &val->offset); + vn_encode_VkDeviceSize(enc, &val->size); +} + +static inline void +vn_encode_VkBufferMemoryBarrier2(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 }); + vn_encode_VkBufferMemoryBarrier2_pnext(enc, val->pNext); + vn_encode_VkBufferMemoryBarrier2_self(enc, val); +} + +/* struct VkImageMemoryBarrier2 chain */ + +static inline size_t +vn_sizeof_VkImageMemoryBarrier2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageMemoryBarrier2_self(const VkImageMemoryBarrier2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags64(&val->srcStageMask); + size += vn_sizeof_VkFlags64(&val->srcAccessMask); + size += vn_sizeof_VkFlags64(&val->dstStageMask); + size += vn_sizeof_VkFlags64(&val->dstAccessMask); + size += vn_sizeof_VkImageLayout(&val->oldLayout); + size += vn_sizeof_VkImageLayout(&val->newLayout); + size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex); + size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex); + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange); + return size; +} + +static inline size_t +vn_sizeof_VkImageMemoryBarrier2(const VkImageMemoryBarrier2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageMemoryBarrier2_pnext(val->pNext); + size += vn_sizeof_VkImageMemoryBarrier2_self(val); + + return size; +} + +static inline void +vn_encode_VkImageMemoryBarrier2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageMemoryBarrier2_self(struct vn_cs_encoder *enc, const VkImageMemoryBarrier2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags64(enc, &val->srcStageMask); + vn_encode_VkFlags64(enc, &val->srcAccessMask); + vn_encode_VkFlags64(enc, &val->dstStageMask); + vn_encode_VkFlags64(enc, &val->dstAccessMask); + vn_encode_VkImageLayout(enc, &val->oldLayout); + vn_encode_VkImageLayout(enc, &val->newLayout); + vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex); + vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex); + vn_encode_VkImage(enc, &val->image); + vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange); +} + +static inline void +vn_encode_VkImageMemoryBarrier2(struct vn_cs_encoder *enc, const VkImageMemoryBarrier2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 }); + vn_encode_VkImageMemoryBarrier2_pnext(enc, val->pNext); + vn_encode_VkImageMemoryBarrier2_self(enc, val); +} + +/* struct VkDependencyInfo chain */ + +static inline size_t +vn_sizeof_VkDependencyInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDependencyInfo_self(const VkDependencyInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->dependencyFlags); + size += vn_sizeof_uint32_t(&val->memoryBarrierCount); + if (val->pMemoryBarriers) { + size += vn_sizeof_array_size(val->memoryBarrierCount); + for (uint32_t i = 0; i < val->memoryBarrierCount; i++) + size += vn_sizeof_VkMemoryBarrier2(&val->pMemoryBarriers[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->bufferMemoryBarrierCount); + if (val->pBufferMemoryBarriers) { + size += vn_sizeof_array_size(val->bufferMemoryBarrierCount); + for (uint32_t i = 0; i < val->bufferMemoryBarrierCount; i++) + size += vn_sizeof_VkBufferMemoryBarrier2(&val->pBufferMemoryBarriers[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->imageMemoryBarrierCount); + if (val->pImageMemoryBarriers) { + size += vn_sizeof_array_size(val->imageMemoryBarrierCount); + for (uint32_t i = 0; i < val->imageMemoryBarrierCount; i++) + size += vn_sizeof_VkImageMemoryBarrier2(&val->pImageMemoryBarriers[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDependencyInfo(const VkDependencyInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDependencyInfo_pnext(val->pNext); + size += vn_sizeof_VkDependencyInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDependencyInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDependencyInfo_self(struct vn_cs_encoder *enc, const VkDependencyInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->dependencyFlags); + vn_encode_uint32_t(enc, &val->memoryBarrierCount); + if (val->pMemoryBarriers) { + vn_encode_array_size(enc, val->memoryBarrierCount); + for (uint32_t i = 0; i < val->memoryBarrierCount; i++) + vn_encode_VkMemoryBarrier2(enc, &val->pMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->bufferMemoryBarrierCount); + if (val->pBufferMemoryBarriers) { + vn_encode_array_size(enc, val->bufferMemoryBarrierCount); + for (uint32_t i = 0; i < val->bufferMemoryBarrierCount; i++) + vn_encode_VkBufferMemoryBarrier2(enc, &val->pBufferMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->imageMemoryBarrierCount); + if (val->pImageMemoryBarriers) { + vn_encode_array_size(enc, val->imageMemoryBarrierCount); + for (uint32_t i = 0; i < val->imageMemoryBarrierCount; i++) + vn_encode_VkImageMemoryBarrier2(enc, &val->pImageMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDependencyInfo(struct vn_cs_encoder *enc, const VkDependencyInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEPENDENCY_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEPENDENCY_INFO }); + vn_encode_VkDependencyInfo_pnext(enc, val->pNext); + vn_encode_VkDependencyInfo_self(enc, val); +} + +/* struct VkRenderingAttachmentInfo chain */ + +static inline size_t +vn_sizeof_VkRenderingAttachmentInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderingAttachmentInfo_self(const VkRenderingAttachmentInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageView(&val->imageView); + size += vn_sizeof_VkImageLayout(&val->imageLayout); + size += vn_sizeof_VkResolveModeFlagBits(&val->resolveMode); + size += vn_sizeof_VkImageView(&val->resolveImageView); + size += vn_sizeof_VkImageLayout(&val->resolveImageLayout); + size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp); + size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp); + size += vn_sizeof_VkClearValue(&val->clearValue); + return size; +} + +static inline size_t +vn_sizeof_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderingAttachmentInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderingAttachmentInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderingAttachmentInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderingAttachmentInfo_self(struct vn_cs_encoder *enc, const VkRenderingAttachmentInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageView(enc, &val->imageView); + vn_encode_VkImageLayout(enc, &val->imageLayout); + vn_encode_VkResolveModeFlagBits(enc, &val->resolveMode); + vn_encode_VkImageView(enc, &val->resolveImageView); + vn_encode_VkImageLayout(enc, &val->resolveImageLayout); + vn_encode_VkAttachmentLoadOp(enc, &val->loadOp); + vn_encode_VkAttachmentStoreOp(enc, &val->storeOp); + vn_encode_VkClearValue(enc, &val->clearValue); +} + +static inline void +vn_encode_VkRenderingAttachmentInfo(struct vn_cs_encoder *enc, const VkRenderingAttachmentInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO }); + vn_encode_VkRenderingAttachmentInfo_pnext(enc, val->pNext); + vn_encode_VkRenderingAttachmentInfo_self(enc, val); +} + +/* struct VkRenderingInfo chain */ + +static inline size_t +vn_sizeof_VkRenderingInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkRenderingInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self((const VkDeviceGroupRenderPassBeginInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderingInfo_self(const VkRenderingInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkRect2D(&val->renderArea); + size += vn_sizeof_uint32_t(&val->layerCount); + size += vn_sizeof_uint32_t(&val->viewMask); + size += vn_sizeof_uint32_t(&val->colorAttachmentCount); + if (val->pColorAttachments) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + size += vn_sizeof_VkRenderingAttachmentInfo(&val->pColorAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_simple_pointer(val->pDepthAttachment); + if (val->pDepthAttachment) + size += vn_sizeof_VkRenderingAttachmentInfo(val->pDepthAttachment); + size += vn_sizeof_simple_pointer(val->pStencilAttachment); + if (val->pStencilAttachment) + size += vn_sizeof_VkRenderingAttachmentInfo(val->pStencilAttachment); + return size; +} + +static inline size_t +vn_sizeof_VkRenderingInfo(const VkRenderingInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderingInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderingInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderingInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkRenderingInfo_pnext(enc, pnext->pNext); + vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, (const VkDeviceGroupRenderPassBeginInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderingInfo_self(struct vn_cs_encoder *enc, const VkRenderingInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkRect2D(enc, &val->renderArea); + vn_encode_uint32_t(enc, &val->layerCount); + vn_encode_uint32_t(enc, &val->viewMask); + vn_encode_uint32_t(enc, &val->colorAttachmentCount); + if (val->pColorAttachments) { + vn_encode_array_size(enc, val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + vn_encode_VkRenderingAttachmentInfo(enc, &val->pColorAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, val->pDepthAttachment)) + vn_encode_VkRenderingAttachmentInfo(enc, val->pDepthAttachment); + if (vn_encode_simple_pointer(enc, val->pStencilAttachment)) + vn_encode_VkRenderingAttachmentInfo(enc, val->pStencilAttachment); +} + +static inline void +vn_encode_VkRenderingInfo(struct vn_cs_encoder *enc, const VkRenderingInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDERING_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDERING_INFO }); + vn_encode_VkRenderingInfo_pnext(enc, val->pNext); + vn_encode_VkRenderingInfo_self(enc, val); +} + static inline size_t vn_sizeof_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT; @@ -5077,6 +6422,1507 @@ static inline void vn_decode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_de /* skip vertexStride */ } +static inline size_t vn_sizeof_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetCullMode_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&cullMode); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetCullMode(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetCullMode_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &cullMode); +} + +static inline size_t vn_sizeof_vkCmdSetCullMode_reply(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetCullMode_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip cullMode */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetCullMode_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetCullMode_EXT); + + /* skip commandBuffer */ + /* skip cullMode */ +} + +static inline size_t vn_sizeof_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFrontFace(&frontFace); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetFrontFace(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFrontFace(enc, &frontFace); +} + +static inline size_t vn_sizeof_vkCmdSetFrontFace_reply(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip frontFace */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetFrontFace_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT); + + /* skip commandBuffer */ + /* skip frontFace */ +} + +static inline size_t vn_sizeof_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkPrimitiveTopology(&primitiveTopology); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetPrimitiveTopology(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkPrimitiveTopology(enc, &primitiveTopology); +} + +static inline size_t vn_sizeof_vkCmdSetPrimitiveTopology_reply(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip primitiveTopology */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetPrimitiveTopology_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT); + + /* skip commandBuffer */ + /* skip primitiveTopology */ +} + +static inline size_t vn_sizeof_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&viewportCount); + if (pViewports) { + cmd_size += vn_sizeof_array_size(viewportCount); + for (uint32_t i = 0; i < viewportCount; i++) + cmd_size += vn_sizeof_VkViewport(&pViewports[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetViewportWithCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &viewportCount); + if (pViewports) { + vn_encode_array_size(enc, viewportCount); + for (uint32_t i = 0; i < viewportCount; i++) + vn_encode_VkViewport(enc, &pViewports[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdSetViewportWithCount_reply(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip viewportCount */ + /* skip pViewports */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetViewportWithCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT); + + /* skip commandBuffer */ + /* skip viewportCount */ + /* skip pViewports */ +} + +static inline size_t vn_sizeof_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&scissorCount); + if (pScissors) { + cmd_size += vn_sizeof_array_size(scissorCount); + for (uint32_t i = 0; i < scissorCount; i++) + cmd_size += vn_sizeof_VkRect2D(&pScissors[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetScissorWithCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &scissorCount); + if (pScissors) { + vn_encode_array_size(enc, scissorCount); + for (uint32_t i = 0; i < scissorCount; i++) + vn_encode_VkRect2D(enc, &pScissors[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdSetScissorWithCount_reply(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip scissorCount */ + /* skip pScissors */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetScissorWithCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT); + + /* skip commandBuffer */ + /* skip scissorCount */ + /* skip pScissors */ +} + +static inline size_t vn_sizeof_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstBinding); + cmd_size += vn_sizeof_uint32_t(&bindingCount); + if (pBuffers) { + cmd_size += vn_sizeof_array_size(bindingCount); + for (uint32_t i = 0; i < bindingCount; i++) + cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pOffsets) { + cmd_size += vn_sizeof_array_size(bindingCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pSizes) { + cmd_size += vn_sizeof_array_size(bindingCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pSizes, bindingCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pStrides) { + cmd_size += vn_sizeof_array_size(bindingCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pStrides, bindingCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdBindVertexBuffers2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstBinding); + vn_encode_uint32_t(enc, &bindingCount); + if (pBuffers) { + vn_encode_array_size(enc, bindingCount); + for (uint32_t i = 0; i < bindingCount; i++) + vn_encode_VkBuffer(enc, &pBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pOffsets) { + vn_encode_array_size(enc, bindingCount); + vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount); + } else { + vn_encode_array_size(enc, 0); + } + if (pSizes) { + vn_encode_array_size(enc, bindingCount); + vn_encode_VkDeviceSize_array(enc, pSizes, bindingCount); + } else { + vn_encode_array_size(enc, 0); + } + if (pStrides) { + vn_encode_array_size(enc, bindingCount); + vn_encode_VkDeviceSize_array(enc, pStrides, bindingCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdBindVertexBuffers2_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstBinding */ + /* skip bindingCount */ + /* skip pBuffers */ + /* skip pOffsets */ + /* skip pSizes */ + /* skip pStrides */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBindVertexBuffers2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT); + + /* skip commandBuffer */ + /* skip firstBinding */ + /* skip bindingCount */ + /* skip pBuffers */ + /* skip pOffsets */ + /* skip pSizes */ + /* skip pStrides */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&depthTestEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthTestEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &depthTestEnable); +} + +static inline size_t vn_sizeof_vkCmdSetDepthTestEnable_reply(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip depthTestEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthTestEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT); + + /* skip commandBuffer */ + /* skip depthTestEnable */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&depthWriteEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthWriteEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &depthWriteEnable); +} + +static inline size_t vn_sizeof_vkCmdSetDepthWriteEnable_reply(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip depthWriteEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthWriteEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT); + + /* skip commandBuffer */ + /* skip depthWriteEnable */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkCompareOp(&depthCompareOp); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthCompareOp(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkCompareOp(enc, &depthCompareOp); +} + +static inline size_t vn_sizeof_vkCmdSetDepthCompareOp_reply(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip depthCompareOp */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthCompareOp_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT); + + /* skip commandBuffer */ + /* skip depthCompareOp */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&depthBoundsTestEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthBoundsTestEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &depthBoundsTestEnable); +} + +static inline size_t vn_sizeof_vkCmdSetDepthBoundsTestEnable_reply(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip depthBoundsTestEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthBoundsTestEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT); + + /* skip commandBuffer */ + /* skip depthBoundsTestEnable */ +} + +static inline size_t vn_sizeof_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&stencilTestEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetStencilTestEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &stencilTestEnable); +} + +static inline size_t vn_sizeof_vkCmdSetStencilTestEnable_reply(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip stencilTestEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetStencilTestEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT); + + /* skip commandBuffer */ + /* skip stencilTestEnable */ +} + +static inline size_t vn_sizeof_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&faceMask); + cmd_size += vn_sizeof_VkStencilOp(&failOp); + cmd_size += vn_sizeof_VkStencilOp(&passOp); + cmd_size += vn_sizeof_VkStencilOp(&depthFailOp); + cmd_size += vn_sizeof_VkCompareOp(&compareOp); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetStencilOp(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &faceMask); + vn_encode_VkStencilOp(enc, &failOp); + vn_encode_VkStencilOp(enc, &passOp); + vn_encode_VkStencilOp(enc, &depthFailOp); + vn_encode_VkCompareOp(enc, &compareOp); +} + +static inline size_t vn_sizeof_vkCmdSetStencilOp_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip failOp */ + /* skip passOp */ + /* skip depthFailOp */ + /* skip compareOp */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetStencilOp_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip failOp */ + /* skip passOp */ + /* skip depthFailOp */ + /* skip compareOp */ +} + +static inline size_t vn_sizeof_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&patchControlPoints); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetPatchControlPointsEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &patchControlPoints); +} + +static inline size_t vn_sizeof_vkCmdSetPatchControlPointsEXT_reply(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip patchControlPoints */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetPatchControlPointsEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT); + + /* skip commandBuffer */ + /* skip patchControlPoints */ +} + +static inline size_t vn_sizeof_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&rasterizerDiscardEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetRasterizerDiscardEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &rasterizerDiscardEnable); +} + +static inline size_t vn_sizeof_vkCmdSetRasterizerDiscardEnable_reply(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip rasterizerDiscardEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetRasterizerDiscardEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT); + + /* skip commandBuffer */ + /* skip rasterizerDiscardEnable */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&depthBiasEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthBiasEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &depthBiasEnable); +} + +static inline size_t vn_sizeof_vkCmdSetDepthBiasEnable_reply(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip depthBiasEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthBiasEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT); + + /* skip commandBuffer */ + /* skip depthBiasEnable */ +} + +static inline size_t vn_sizeof_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkLogicOp(&logicOp); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetLogicOpEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkLogicOp(enc, &logicOp); +} + +static inline size_t vn_sizeof_vkCmdSetLogicOpEXT_reply(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip logicOp */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetLogicOpEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT); + + /* skip commandBuffer */ + /* skip logicOp */ +} + +static inline size_t vn_sizeof_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBool32(&primitiveRestartEnable); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetPrimitiveRestartEnable(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBool32(enc, &primitiveRestartEnable); +} + +static inline size_t vn_sizeof_vkCmdSetPrimitiveRestartEnable_reply(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip primitiveRestartEnable */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetPrimitiveRestartEnable_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT); + + /* skip commandBuffer */ + /* skip primitiveRestartEnable */ +} + +static inline size_t vn_sizeof_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pCopyBufferInfo); + if (pCopyBufferInfo) + cmd_size += vn_sizeof_VkCopyBufferInfo2(pCopyBufferInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyBuffer2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pCopyBufferInfo)) + vn_encode_VkCopyBufferInfo2(enc, pCopyBufferInfo); +} + +static inline size_t vn_sizeof_vkCmdCopyBuffer2_reply(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pCopyBufferInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyBuffer2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT); + + /* skip commandBuffer */ + /* skip pCopyBufferInfo */ +} + +static inline size_t vn_sizeof_vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pCopyImageInfo); + if (pCopyImageInfo) + cmd_size += vn_sizeof_VkCopyImageInfo2(pCopyImageInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyImage2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pCopyImageInfo)) + vn_encode_VkCopyImageInfo2(enc, pCopyImageInfo); +} + +static inline size_t vn_sizeof_vkCmdCopyImage2_reply(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pCopyImageInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyImage2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImage2_EXT); + + /* skip commandBuffer */ + /* skip pCopyImageInfo */ +} + +static inline size_t vn_sizeof_vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pBlitImageInfo); + if (pBlitImageInfo) + cmd_size += vn_sizeof_VkBlitImageInfo2(pBlitImageInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBlitImage2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pBlitImageInfo)) + vn_encode_VkBlitImageInfo2(enc, pBlitImageInfo); +} + +static inline size_t vn_sizeof_vkCmdBlitImage2_reply(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pBlitImageInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBlitImage2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBlitImage2_EXT); + + /* skip commandBuffer */ + /* skip pBlitImageInfo */ +} + +static inline size_t vn_sizeof_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pCopyBufferToImageInfo); + if (pCopyBufferToImageInfo) + cmd_size += vn_sizeof_VkCopyBufferToImageInfo2(pCopyBufferToImageInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyBufferToImage2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pCopyBufferToImageInfo)) + vn_encode_VkCopyBufferToImageInfo2(enc, pCopyBufferToImageInfo); +} + +static inline size_t vn_sizeof_vkCmdCopyBufferToImage2_reply(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pCopyBufferToImageInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyBufferToImage2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT); + + /* skip commandBuffer */ + /* skip pCopyBufferToImageInfo */ +} + +static inline size_t vn_sizeof_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pCopyImageToBufferInfo); + if (pCopyImageToBufferInfo) + cmd_size += vn_sizeof_VkCopyImageToBufferInfo2(pCopyImageToBufferInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyImageToBuffer2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pCopyImageToBufferInfo)) + vn_encode_VkCopyImageToBufferInfo2(enc, pCopyImageToBufferInfo); +} + +static inline size_t vn_sizeof_vkCmdCopyImageToBuffer2_reply(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pCopyImageToBufferInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyImageToBuffer2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT); + + /* skip commandBuffer */ + /* skip pCopyImageToBufferInfo */ +} + +static inline size_t vn_sizeof_vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pResolveImageInfo); + if (pResolveImageInfo) + cmd_size += vn_sizeof_VkResolveImageInfo2(pResolveImageInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdResolveImage2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pResolveImageInfo)) + vn_encode_VkResolveImageInfo2(enc, pResolveImageInfo); +} + +static inline size_t vn_sizeof_vkCmdResolveImage2_reply(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pResolveImageInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdResolveImage2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdResolveImage2_EXT); + + /* skip commandBuffer */ + /* skip pResolveImageInfo */ +} + +static inline size_t vn_sizeof_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkEvent(&event); + cmd_size += vn_sizeof_simple_pointer(pDependencyInfo); + if (pDependencyInfo) + cmd_size += vn_sizeof_VkDependencyInfo(pDependencyInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetEvent2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkEvent(enc, &event); + if (vn_encode_simple_pointer(enc, pDependencyInfo)) + vn_encode_VkDependencyInfo(enc, pDependencyInfo); +} + +static inline size_t vn_sizeof_vkCmdSetEvent2_reply(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip event */ + /* skip pDependencyInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetEvent2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetEvent2_EXT); + + /* skip commandBuffer */ + /* skip event */ + /* skip pDependencyInfo */ +} + +static inline size_t vn_sizeof_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkEvent(&event); + cmd_size += vn_sizeof_VkFlags64(&stageMask); + + return cmd_size; +} + +static inline void vn_encode_vkCmdResetEvent2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkEvent(enc, &event); + vn_encode_VkFlags64(enc, &stageMask); +} + +static inline size_t vn_sizeof_vkCmdResetEvent2_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip event */ + /* skip stageMask */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdResetEvent2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdResetEvent2_EXT); + + /* skip commandBuffer */ + /* skip event */ + /* skip stageMask */ +} + +static inline size_t vn_sizeof_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&eventCount); + if (pEvents) { + cmd_size += vn_sizeof_array_size(eventCount); + for (uint32_t i = 0; i < eventCount; i++) + cmd_size += vn_sizeof_VkEvent(&pEvents[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pDependencyInfos) { + cmd_size += vn_sizeof_array_size(eventCount); + for (uint32_t i = 0; i < eventCount; i++) + cmd_size += vn_sizeof_VkDependencyInfo(&pDependencyInfos[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdWaitEvents2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &eventCount); + if (pEvents) { + vn_encode_array_size(enc, eventCount); + for (uint32_t i = 0; i < eventCount; i++) + vn_encode_VkEvent(enc, &pEvents[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pDependencyInfos) { + vn_encode_array_size(enc, eventCount); + for (uint32_t i = 0; i < eventCount; i++) + vn_encode_VkDependencyInfo(enc, &pDependencyInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdWaitEvents2_reply(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip eventCount */ + /* skip pEvents */ + /* skip pDependencyInfos */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdWaitEvents2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT); + + /* skip commandBuffer */ + /* skip eventCount */ + /* skip pEvents */ + /* skip pDependencyInfos */ +} + +static inline size_t vn_sizeof_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pDependencyInfo); + if (pDependencyInfo) + cmd_size += vn_sizeof_VkDependencyInfo(pDependencyInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdPipelineBarrier2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pDependencyInfo)) + vn_encode_VkDependencyInfo(enc, pDependencyInfo); +} + +static inline size_t vn_sizeof_vkCmdPipelineBarrier2_reply(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pDependencyInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdPipelineBarrier2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT); + + /* skip commandBuffer */ + /* skip pDependencyInfo */ +} + +static inline size_t vn_sizeof_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags64(&stage); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&query); + + return cmd_size; +} + +static inline void vn_encode_vkCmdWriteTimestamp2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags64(enc, &stage); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &query); +} + +static inline size_t vn_sizeof_vkCmdWriteTimestamp2_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip stage */ + /* skip queryPool */ + /* skip query */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdWriteTimestamp2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT); + + /* skip commandBuffer */ + /* skip stage */ + /* skip queryPool */ + /* skip query */ +} + +static inline size_t vn_sizeof_vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRendering_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pRenderingInfo); + if (pRenderingInfo) + cmd_size += vn_sizeof_VkRenderingInfo(pRenderingInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBeginRendering(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRendering_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pRenderingInfo)) + vn_encode_VkRenderingInfo(enc, pRenderingInfo); +} + +static inline size_t vn_sizeof_vkCmdBeginRendering_reply(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRendering_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pRenderingInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBeginRendering_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRendering_EXT); + + /* skip commandBuffer */ + /* skip pRenderingInfo */ +} + +static inline size_t vn_sizeof_vkCmdEndRendering(VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRendering_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + + return cmd_size; +} + +static inline void vn_encode_vkCmdEndRendering(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRendering_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); +} + +static inline size_t vn_sizeof_vkCmdEndRendering_reply(VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRendering_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdEndRendering_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdEndRendering_EXT); + + /* skip commandBuffer */ +} + static inline void vn_submit_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit) { uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; @@ -6379,6 +9225,636 @@ static inline void vn_submit_vkCmdDrawIndirectByteCountEXT(struct vn_instance *v } } +static inline void vn_submit_vkCmdSetCullMode(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetCullMode(commandBuffer, cullMode); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetCullMode_reply(commandBuffer, cullMode) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetCullMode(enc, cmd_flags, commandBuffer, cullMode); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetFrontFace(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkFrontFace frontFace, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetFrontFace(commandBuffer, frontFace); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetFrontFace_reply(commandBuffer, frontFace) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetFrontFace(enc, cmd_flags, commandBuffer, frontFace); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetPrimitiveTopology(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetPrimitiveTopology_reply(commandBuffer, primitiveTopology) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetPrimitiveTopology(enc, cmd_flags, commandBuffer, primitiveTopology); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetViewportWithCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetViewportWithCount_reply(commandBuffer, viewportCount, pViewports) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetViewportWithCount(enc, cmd_flags, commandBuffer, viewportCount, pViewports); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetScissorWithCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetScissorWithCount_reply(commandBuffer, scissorCount, pScissors) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetScissorWithCount(enc, cmd_flags, commandBuffer, scissorCount, pScissors); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdBindVertexBuffers2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindVertexBuffers2_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdBindVertexBuffers2(enc, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetDepthTestEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthTestEnable_reply(commandBuffer, depthTestEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetDepthTestEnable(enc, cmd_flags, commandBuffer, depthTestEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetDepthWriteEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthWriteEnable_reply(commandBuffer, depthWriteEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetDepthWriteEnable(enc, cmd_flags, commandBuffer, depthWriteEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetDepthCompareOp(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthCompareOp_reply(commandBuffer, depthCompareOp) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetDepthCompareOp(enc, cmd_flags, commandBuffer, depthCompareOp); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetDepthBoundsTestEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBoundsTestEnable_reply(commandBuffer, depthBoundsTestEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetDepthBoundsTestEnable(enc, cmd_flags, commandBuffer, depthBoundsTestEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetStencilTestEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilTestEnable_reply(commandBuffer, stencilTestEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetStencilTestEnable(enc, cmd_flags, commandBuffer, stencilTestEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetStencilOp(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilOp_reply(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetStencilOp(enc, cmd_flags, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetPatchControlPointsEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t patchControlPoints, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetPatchControlPointsEXT_reply(commandBuffer, patchControlPoints) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetPatchControlPointsEXT(enc, cmd_flags, commandBuffer, patchControlPoints); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetRasterizerDiscardEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetRasterizerDiscardEnable_reply(commandBuffer, rasterizerDiscardEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetRasterizerDiscardEnable(enc, cmd_flags, commandBuffer, rasterizerDiscardEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetDepthBiasEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBiasEnable_reply(commandBuffer, depthBiasEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetDepthBiasEnable(enc, cmd_flags, commandBuffer, depthBiasEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetLogicOpEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkLogicOp logicOp, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetLogicOpEXT(commandBuffer, logicOp); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetLogicOpEXT_reply(commandBuffer, logicOp) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetLogicOpEXT(enc, cmd_flags, commandBuffer, logicOp); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetPrimitiveRestartEnable(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetPrimitiveRestartEnable_reply(commandBuffer, primitiveRestartEnable) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetPrimitiveRestartEnable(enc, cmd_flags, commandBuffer, primitiveRestartEnable); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdCopyBuffer2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBuffer2_reply(commandBuffer, pCopyBufferInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdCopyBuffer2(enc, cmd_flags, commandBuffer, pCopyBufferInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdCopyImage2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyImage2(commandBuffer, pCopyImageInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImage2_reply(commandBuffer, pCopyImageInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdCopyImage2(enc, cmd_flags, commandBuffer, pCopyImageInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdBlitImage2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBlitImage2(commandBuffer, pBlitImageInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBlitImage2_reply(commandBuffer, pBlitImageInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdBlitImage2(enc, cmd_flags, commandBuffer, pBlitImageInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdCopyBufferToImage2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBufferToImage2_reply(commandBuffer, pCopyBufferToImageInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdCopyBufferToImage2(enc, cmd_flags, commandBuffer, pCopyBufferToImageInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdCopyImageToBuffer2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImageToBuffer2_reply(commandBuffer, pCopyImageToBufferInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdCopyImageToBuffer2(enc, cmd_flags, commandBuffer, pCopyImageToBufferInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdResolveImage2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdResolveImage2(commandBuffer, pResolveImageInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResolveImage2_reply(commandBuffer, pResolveImageInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdResolveImage2(enc, cmd_flags, commandBuffer, pResolveImageInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdSetEvent2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetEvent2_reply(commandBuffer, event, pDependencyInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdSetEvent2(enc, cmd_flags, commandBuffer, event, pDependencyInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdResetEvent2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdResetEvent2(commandBuffer, event, stageMask); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetEvent2_reply(commandBuffer, event, stageMask) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdResetEvent2(enc, cmd_flags, commandBuffer, event, stageMask); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdWaitEvents2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWaitEvents2_reply(commandBuffer, eventCount, pEvents, pDependencyInfos) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdWaitEvents2(enc, cmd_flags, commandBuffer, eventCount, pEvents, pDependencyInfos); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdPipelineBarrier2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPipelineBarrier2_reply(commandBuffer, pDependencyInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdPipelineBarrier2(enc, cmd_flags, commandBuffer, pDependencyInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdWriteTimestamp2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWriteTimestamp2_reply(commandBuffer, stage, queryPool, query) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdWriteTimestamp2(enc, cmd_flags, commandBuffer, stage, queryPool, query); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdBeginRendering(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBeginRendering(commandBuffer, pRenderingInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRendering_reply(commandBuffer, pRenderingInfo) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdBeginRendering(enc, cmd_flags, commandBuffer, pRenderingInfo); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkCmdEndRendering(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdEndRendering(commandBuffer); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRendering_reply(commandBuffer) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCmdEndRendering(enc, cmd_flags, commandBuffer); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + static inline VkResult vn_call_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { VN_TRACE_FUNC(); @@ -7569,4 +11045,574 @@ static inline void vn_async_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, 0, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit); } +static inline void vn_call_vkCmdSetCullMode(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetCullMode(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, cullMode, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetCullMode_reply(dec, commandBuffer, cullMode); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetCullMode(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetCullMode(vn_instance, 0, commandBuffer, cullMode, &submit); +} + +static inline void vn_call_vkCmdSetFrontFace(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetFrontFace(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, frontFace, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetFrontFace_reply(dec, commandBuffer, frontFace); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetFrontFace(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetFrontFace(vn_instance, 0, commandBuffer, frontFace, &submit); +} + +static inline void vn_call_vkCmdSetPrimitiveTopology(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetPrimitiveTopology(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, primitiveTopology, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetPrimitiveTopology_reply(dec, commandBuffer, primitiveTopology); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetPrimitiveTopology(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetPrimitiveTopology(vn_instance, 0, commandBuffer, primitiveTopology, &submit); +} + +static inline void vn_call_vkCmdSetViewportWithCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetViewportWithCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, viewportCount, pViewports, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetViewportWithCount_reply(dec, commandBuffer, viewportCount, pViewports); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetViewportWithCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetViewportWithCount(vn_instance, 0, commandBuffer, viewportCount, pViewports, &submit); +} + +static inline void vn_call_vkCmdSetScissorWithCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetScissorWithCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, scissorCount, pScissors, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetScissorWithCount_reply(dec, commandBuffer, scissorCount, pScissors); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetScissorWithCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetScissorWithCount(vn_instance, 0, commandBuffer, scissorCount, pScissors, &submit); +} + +static inline void vn_call_vkCmdBindVertexBuffers2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindVertexBuffers2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdBindVertexBuffers2_reply(dec, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdBindVertexBuffers2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindVertexBuffers2(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, &submit); +} + +static inline void vn_call_vkCmdSetDepthTestEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthTestEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthTestEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetDepthTestEnable_reply(dec, commandBuffer, depthTestEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetDepthTestEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthTestEnable(vn_instance, 0, commandBuffer, depthTestEnable, &submit); +} + +static inline void vn_call_vkCmdSetDepthWriteEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthWriteEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthWriteEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetDepthWriteEnable_reply(dec, commandBuffer, depthWriteEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetDepthWriteEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthWriteEnable(vn_instance, 0, commandBuffer, depthWriteEnable, &submit); +} + +static inline void vn_call_vkCmdSetDepthCompareOp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthCompareOp(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthCompareOp, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetDepthCompareOp_reply(dec, commandBuffer, depthCompareOp); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetDepthCompareOp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthCompareOp(vn_instance, 0, commandBuffer, depthCompareOp, &submit); +} + +static inline void vn_call_vkCmdSetDepthBoundsTestEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBoundsTestEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthBoundsTestEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetDepthBoundsTestEnable_reply(dec, commandBuffer, depthBoundsTestEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetDepthBoundsTestEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBoundsTestEnable(vn_instance, 0, commandBuffer, depthBoundsTestEnable, &submit); +} + +static inline void vn_call_vkCmdSetStencilTestEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilTestEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, stencilTestEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetStencilTestEnable_reply(dec, commandBuffer, stencilTestEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetStencilTestEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilTestEnable(vn_instance, 0, commandBuffer, stencilTestEnable, &submit); +} + +static inline void vn_call_vkCmdSetStencilOp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilOp(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetStencilOp_reply(dec, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetStencilOp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilOp(vn_instance, 0, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, &submit); +} + +static inline void vn_call_vkCmdSetPatchControlPointsEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetPatchControlPointsEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, patchControlPoints, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetPatchControlPointsEXT_reply(dec, commandBuffer, patchControlPoints); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetPatchControlPointsEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetPatchControlPointsEXT(vn_instance, 0, commandBuffer, patchControlPoints, &submit); +} + +static inline void vn_call_vkCmdSetRasterizerDiscardEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetRasterizerDiscardEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, rasterizerDiscardEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetRasterizerDiscardEnable_reply(dec, commandBuffer, rasterizerDiscardEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetRasterizerDiscardEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetRasterizerDiscardEnable(vn_instance, 0, commandBuffer, rasterizerDiscardEnable, &submit); +} + +static inline void vn_call_vkCmdSetDepthBiasEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBiasEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthBiasEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetDepthBiasEnable_reply(dec, commandBuffer, depthBiasEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetDepthBiasEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBiasEnable(vn_instance, 0, commandBuffer, depthBiasEnable, &submit); +} + +static inline void vn_call_vkCmdSetLogicOpEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetLogicOpEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, logicOp, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetLogicOpEXT_reply(dec, commandBuffer, logicOp); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetLogicOpEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetLogicOpEXT(vn_instance, 0, commandBuffer, logicOp, &submit); +} + +static inline void vn_call_vkCmdSetPrimitiveRestartEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetPrimitiveRestartEnable(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, primitiveRestartEnable, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetPrimitiveRestartEnable_reply(dec, commandBuffer, primitiveRestartEnable); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetPrimitiveRestartEnable(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetPrimitiveRestartEnable(vn_instance, 0, commandBuffer, primitiveRestartEnable, &submit); +} + +static inline void vn_call_vkCmdCopyBuffer2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBuffer2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pCopyBufferInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdCopyBuffer2_reply(dec, commandBuffer, pCopyBufferInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdCopyBuffer2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBuffer2(vn_instance, 0, commandBuffer, pCopyBufferInfo, &submit); +} + +static inline void vn_call_vkCmdCopyImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImage2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pCopyImageInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdCopyImage2_reply(dec, commandBuffer, pCopyImageInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdCopyImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImage2(vn_instance, 0, commandBuffer, pCopyImageInfo, &submit); +} + +static inline void vn_call_vkCmdBlitImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdBlitImage2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pBlitImageInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdBlitImage2_reply(dec, commandBuffer, pBlitImageInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdBlitImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBlitImage2(vn_instance, 0, commandBuffer, pBlitImageInfo, &submit); +} + +static inline void vn_call_vkCmdCopyBufferToImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBufferToImage2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pCopyBufferToImageInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdCopyBufferToImage2_reply(dec, commandBuffer, pCopyBufferToImageInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdCopyBufferToImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBufferToImage2(vn_instance, 0, commandBuffer, pCopyBufferToImageInfo, &submit); +} + +static inline void vn_call_vkCmdCopyImageToBuffer2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImageToBuffer2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pCopyImageToBufferInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdCopyImageToBuffer2_reply(dec, commandBuffer, pCopyImageToBufferInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdCopyImageToBuffer2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImageToBuffer2(vn_instance, 0, commandBuffer, pCopyImageToBufferInfo, &submit); +} + +static inline void vn_call_vkCmdResolveImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdResolveImage2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pResolveImageInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdResolveImage2_reply(dec, commandBuffer, pResolveImageInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdResolveImage2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResolveImage2(vn_instance, 0, commandBuffer, pResolveImageInfo, &submit); +} + +static inline void vn_call_vkCmdSetEvent2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetEvent2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, pDependencyInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdSetEvent2_reply(dec, commandBuffer, event, pDependencyInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdSetEvent2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetEvent2(vn_instance, 0, commandBuffer, event, pDependencyInfo, &submit); +} + +static inline void vn_call_vkCmdResetEvent2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdResetEvent2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdResetEvent2_reply(dec, commandBuffer, event, stageMask); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdResetEvent2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResetEvent2(vn_instance, 0, commandBuffer, event, stageMask, &submit); +} + +static inline void vn_call_vkCmdWaitEvents2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdWaitEvents2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, eventCount, pEvents, pDependencyInfos, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdWaitEvents2_reply(dec, commandBuffer, eventCount, pEvents, pDependencyInfos); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdWaitEvents2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdWaitEvents2(vn_instance, 0, commandBuffer, eventCount, pEvents, pDependencyInfos, &submit); +} + +static inline void vn_call_vkCmdPipelineBarrier2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdPipelineBarrier2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pDependencyInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdPipelineBarrier2_reply(dec, commandBuffer, pDependencyInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdPipelineBarrier2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdPipelineBarrier2(vn_instance, 0, commandBuffer, pDependencyInfo, &submit); +} + +static inline void vn_call_vkCmdWriteTimestamp2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdWriteTimestamp2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, stage, queryPool, query, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdWriteTimestamp2_reply(dec, commandBuffer, stage, queryPool, query); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdWriteTimestamp2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdWriteTimestamp2(vn_instance, 0, commandBuffer, stage, queryPool, query, &submit); +} + +static inline void vn_call_vkCmdBeginRendering(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginRendering(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderingInfo, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdBeginRendering_reply(dec, commandBuffer, pRenderingInfo); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdBeginRendering(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginRendering(vn_instance, 0, commandBuffer, pRenderingInfo, &submit); +} + +static inline void vn_call_vkCmdEndRendering(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndRendering(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkCmdEndRendering_reply(dec, commandBuffer); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkCmdEndRendering(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndRendering(vn_instance, 0, commandBuffer, &submit); +} + #endif /* VN_PROTOCOL_DRIVER_COMMAND_BUFFER_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_defines.h b/src/virtio/venus-protocol/vn_protocol_driver_defines.h index 76ee8f926c1..c56710896bd 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_defines.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_defines.h @@ -243,6 +243,80 @@ typedef enum VkCommandTypeEXT { VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddressKHR_EXT = 176, VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT = 177, VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddressKHR_EXT = 177, + VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT = 196, + VK_COMMAND_TYPE_vkGetPhysicalDeviceToolPropertiesEXT_EXT = 196, + VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT = 197, + VK_COMMAND_TYPE_vkCreatePrivateDataSlotEXT_EXT = 197, + VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT = 198, + VK_COMMAND_TYPE_vkDestroyPrivateDataSlotEXT_EXT = 198, + VK_COMMAND_TYPE_vkSetPrivateData_EXT = 199, + VK_COMMAND_TYPE_vkSetPrivateDataEXT_EXT = 199, + VK_COMMAND_TYPE_vkGetPrivateData_EXT = 200, + VK_COMMAND_TYPE_vkGetPrivateDataEXT_EXT = 200, + VK_COMMAND_TYPE_vkCmdSetEvent2_EXT = 201, + VK_COMMAND_TYPE_vkCmdSetEvent2KHR_EXT = 201, + VK_COMMAND_TYPE_vkCmdResetEvent2_EXT = 202, + VK_COMMAND_TYPE_vkCmdResetEvent2KHR_EXT = 202, + VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT = 203, + VK_COMMAND_TYPE_vkCmdWaitEvents2KHR_EXT = 203, + VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT = 204, + VK_COMMAND_TYPE_vkCmdPipelineBarrier2KHR_EXT = 204, + VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT = 205, + VK_COMMAND_TYPE_vkCmdWriteTimestamp2KHR_EXT = 205, + VK_COMMAND_TYPE_vkQueueSubmit2_EXT = 206, + VK_COMMAND_TYPE_vkQueueSubmit2KHR_EXT = 206, + VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT = 207, + VK_COMMAND_TYPE_vkCmdCopyBuffer2KHR_EXT = 207, + VK_COMMAND_TYPE_vkCmdCopyImage2_EXT = 208, + VK_COMMAND_TYPE_vkCmdCopyImage2KHR_EXT = 208, + VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT = 209, + VK_COMMAND_TYPE_vkCmdCopyBufferToImage2KHR_EXT = 209, + VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT = 210, + VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2KHR_EXT = 210, + VK_COMMAND_TYPE_vkCmdBlitImage2_EXT = 211, + VK_COMMAND_TYPE_vkCmdBlitImage2KHR_EXT = 211, + VK_COMMAND_TYPE_vkCmdResolveImage2_EXT = 212, + VK_COMMAND_TYPE_vkCmdResolveImage2KHR_EXT = 212, + VK_COMMAND_TYPE_vkCmdBeginRendering_EXT = 213, + VK_COMMAND_TYPE_vkCmdBeginRenderingKHR_EXT = 213, + VK_COMMAND_TYPE_vkCmdEndRendering_EXT = 214, + VK_COMMAND_TYPE_vkCmdEndRenderingKHR_EXT = 214, + VK_COMMAND_TYPE_vkCmdSetCullMode_EXT = 215, + VK_COMMAND_TYPE_vkCmdSetCullModeEXT_EXT = 215, + VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT = 216, + VK_COMMAND_TYPE_vkCmdSetFrontFaceEXT_EXT = 216, + VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT = 217, + VK_COMMAND_TYPE_vkCmdSetPrimitiveTopologyEXT_EXT = 217, + VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT = 218, + VK_COMMAND_TYPE_vkCmdSetViewportWithCountEXT_EXT = 218, + VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT = 219, + VK_COMMAND_TYPE_vkCmdSetScissorWithCountEXT_EXT = 219, + VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT = 220, + VK_COMMAND_TYPE_vkCmdBindVertexBuffers2EXT_EXT = 220, + VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT = 221, + VK_COMMAND_TYPE_vkCmdSetDepthTestEnableEXT_EXT = 221, + VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT = 222, + VK_COMMAND_TYPE_vkCmdSetDepthWriteEnableEXT_EXT = 222, + VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT = 223, + VK_COMMAND_TYPE_vkCmdSetDepthCompareOpEXT_EXT = 223, + VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT = 224, + VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnableEXT_EXT = 224, + VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT = 225, + VK_COMMAND_TYPE_vkCmdSetStencilTestEnableEXT_EXT = 225, + VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT = 226, + VK_COMMAND_TYPE_vkCmdSetStencilOpEXT_EXT = 226, + VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT = 227, + VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnableEXT_EXT = 227, + VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT = 228, + VK_COMMAND_TYPE_vkCmdSetDepthBiasEnableEXT_EXT = 228, + VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT = 229, + VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnableEXT_EXT = 229, + VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT = 230, + VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirementsKHR_EXT = 230, + VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT = 231, + VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirementsKHR_EXT = 231, + VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT = 232, + VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirementsKHR_EXT = 232, VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT = 181, VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT = 182, VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT = 183, @@ -252,6 +326,8 @@ typedef enum VkCommandTypeEXT { VK_COMMAND_TYPE_vkGetMemoryFdKHR_EXT = 193, VK_COMMAND_TYPE_vkGetMemoryFdPropertiesKHR_EXT = 194, VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT = 187, + VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT = 233, + VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT = 234, VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT = 178, VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT = 179, VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT = 180, diff --git a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h index c08f81fa121..db09463d6e4 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h @@ -29,12 +29,82 @@ vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPool vn_encode_uint32_t(enc, &val->descriptorCount); } +/* struct VkDescriptorPoolInlineUniformBlockCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_self(const VkDescriptorPoolInlineUniformBlockCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockBindings); + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolInlineUniformBlockCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->maxInlineUniformBlockBindings); +} + +static inline void +vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolInlineUniformBlockCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO }); + vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_self(enc, val); +} + /* struct VkDescriptorPoolCreateInfo chain */ static inline size_t vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_self((const VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -71,7 +141,23 @@ vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val) static inline void vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_self(enc, (const VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } diff --git a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h index 4c91b7b4c09..57ff35d180f 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h @@ -224,12 +224,94 @@ vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBu vn_encode_VkDeviceSize(enc, &val->range); } +/* struct VkWriteDescriptorSetInlineUniformBlock chain */ + +static inline size_t +vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(const VkWriteDescriptorSetInlineUniformBlock *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->dataSize); + if (val->pData) { + size += vn_sizeof_array_size(val->dataSize); + size += vn_sizeof_blob_array(val->pData, val->dataSize); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(val->pNext); + size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(val); + + return size; +} + +static inline void +vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSetInlineUniformBlock *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->dataSize); + if (val->pData) { + vn_encode_array_size(enc, val->dataSize); + vn_encode_blob_array(enc, val->pData, val->dataSize); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkWriteDescriptorSetInlineUniformBlock(struct vn_cs_encoder *enc, const VkWriteDescriptorSetInlineUniformBlock *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK }); + vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(enc, val->pNext); + vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(enc, val); +} + /* struct VkWriteDescriptorSet chain */ static inline size_t vn_sizeof_VkWriteDescriptorSet_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkWriteDescriptorSet_pnext(pnext->pNext); + size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self((const VkWriteDescriptorSetInlineUniformBlock *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -282,7 +364,23 @@ vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val) static inline void vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkWriteDescriptorSet_pnext(enc, pnext->pNext); + vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(enc, (const VkWriteDescriptorSetInlineUniformBlock *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } diff --git a/src/virtio/venus-protocol/vn_protocol_driver_device.h b/src/virtio/venus-protocol/vn_protocol_driver_device.h index 72163260b25..86ee1a4b6a6 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_device.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_device.h @@ -1238,6 +1238,190 @@ vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder *enc, const VkDeviceQueue vn_encode_VkDeviceQueueCreateInfo_self(enc, val); } +/* struct VkDevicePrivateDataCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDevicePrivateDataCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDevicePrivateDataCreateInfo_self(const VkDevicePrivateDataCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->privateDataSlotRequestCount); + return size; +} + +static inline size_t +vn_sizeof_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDevicePrivateDataCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDevicePrivateDataCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDevicePrivateDataCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDevicePrivateDataCreateInfo_self(struct vn_cs_encoder *enc, const VkDevicePrivateDataCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->privateDataSlotRequestCount); +} + +static inline void +vn_encode_VkDevicePrivateDataCreateInfo(struct vn_cs_encoder *enc, const VkDevicePrivateDataCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO }); + vn_encode_VkDevicePrivateDataCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDevicePrivateDataCreateInfo_self(enc, val); +} + +/* struct VkPhysicalDevicePrivateDataFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self(const VkPhysicalDevicePrivateDataFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->privateData); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevicePrivateDataFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->privateData); +} + +static inline void +vn_encode_VkPhysicalDevicePrivateDataFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES }); + vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDevicePrivateDataFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDevicePrivateDataFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevicePrivateDataFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->privateData); +} + +static inline void +vn_decode_VkPhysicalDevicePrivateDataFeatures(struct vn_cs_decoder *dec, VkPhysicalDevicePrivateDataFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDevicePrivateDataFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDevicePrivateDataFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial(const VkPhysicalDevicePrivateDataFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->privateData */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePrivateDataFeatures_partial(const VkPhysicalDevicePrivateDataFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->privateData */ +} + +static inline void +vn_encode_VkPhysicalDevicePrivateDataFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES }); + vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(enc, val); +} + /* struct VkPhysicalDeviceVariablePointersFeatures chain */ static inline size_t @@ -2054,6 +2238,273 @@ vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder * vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val); } +/* struct VkPhysicalDeviceInlineUniformBlockFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->inlineUniformBlock); + size += vn_sizeof_VkBool32(&val->descriptorBindingInlineUniformBlockUpdateAfterBind); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->inlineUniformBlock); + vn_encode_VkBool32(enc, &val->descriptorBindingInlineUniformBlockUpdateAfterBind); +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES }); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->inlineUniformBlock); + vn_decode_VkBool32(dec, &val->descriptorBindingInlineUniformBlockUpdateAfterBind); +} + +static inline void +vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->inlineUniformBlock */ + /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_partial(const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->inlineUniformBlock */ + /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */ +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES }); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceMaintenance4Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(const VkPhysicalDeviceMaintenance4Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->maintenance4); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->maintenance4); +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES }); + vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->maintenance4); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial(const VkPhysicalDeviceMaintenance4Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maintenance4 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Features_partial(const VkPhysicalDeviceMaintenance4Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maintenance4 */ +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES }); + vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, val); +} + /* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */ static inline size_t @@ -3897,6 +4348,137 @@ vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_enco vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val); } +/* struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->textureCompressionASTC_HDR); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->textureCompressionASTC_HDR); +} + +static inline void +vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES }); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->textureCompressionASTC_HDR); +} + +static inline void +vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->textureCompressionASTC_HDR */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->textureCompressionASTC_HDR */ +} + +static inline void +vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES }); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(enc, val); +} + /* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */ static inline size_t @@ -4028,6 +4610,535 @@ vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_ vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val); } +/* struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderDemoteToHelperInvocation); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderDemoteToHelperInvocation); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES }); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderDemoteToHelperInvocation); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderDemoteToHelperInvocation */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderDemoteToHelperInvocation */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES }); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->texelBufferAlignment); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->texelBufferAlignment); +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->texelBufferAlignment); +} + +static inline void +vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->texelBufferAlignment */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->texelBufferAlignment */ +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSubgroupSizeControlFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->subgroupSizeControl); + size += vn_sizeof_VkBool32(&val->computeFullSubgroups); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->subgroupSizeControl); + vn_encode_VkBool32(enc, &val->computeFullSubgroups); +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES }); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->subgroupSizeControl); + vn_decode_VkBool32(dec, &val->computeFullSubgroups); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->subgroupSizeControl */ + /* skip val->computeFullSubgroups */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->subgroupSizeControl */ + /* skip val->computeFullSubgroups */ +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES }); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDevicePipelineCreationCacheControlFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->pipelineCreationCacheControl); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->pipelineCreationCacheControl); +} + +static inline void +vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES }); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->pipelineCreationCacheControl); +} + +static inline void +vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_decoder *dec, VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->pipelineCreationCacheControl */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->pipelineCreationCacheControl */ +} + +static inline void +vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES }); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(enc, val); +} + /* struct VkPhysicalDeviceVulkan11Features chain */ static inline size_t @@ -4575,6 +5686,1532 @@ vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, co vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val); } +/* struct VkPhysicalDeviceVulkan13Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Features_self(const VkPhysicalDeviceVulkan13Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->robustImageAccess); + size += vn_sizeof_VkBool32(&val->inlineUniformBlock); + size += vn_sizeof_VkBool32(&val->descriptorBindingInlineUniformBlockUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->pipelineCreationCacheControl); + size += vn_sizeof_VkBool32(&val->privateData); + size += vn_sizeof_VkBool32(&val->shaderDemoteToHelperInvocation); + size += vn_sizeof_VkBool32(&val->shaderTerminateInvocation); + size += vn_sizeof_VkBool32(&val->subgroupSizeControl); + size += vn_sizeof_VkBool32(&val->computeFullSubgroups); + size += vn_sizeof_VkBool32(&val->synchronization2); + size += vn_sizeof_VkBool32(&val->textureCompressionASTC_HDR); + size += vn_sizeof_VkBool32(&val->shaderZeroInitializeWorkgroupMemory); + size += vn_sizeof_VkBool32(&val->dynamicRendering); + size += vn_sizeof_VkBool32(&val->shaderIntegerDotProduct); + size += vn_sizeof_VkBool32(&val->maintenance4); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->robustImageAccess); + vn_encode_VkBool32(enc, &val->inlineUniformBlock); + vn_encode_VkBool32(enc, &val->descriptorBindingInlineUniformBlockUpdateAfterBind); + vn_encode_VkBool32(enc, &val->pipelineCreationCacheControl); + vn_encode_VkBool32(enc, &val->privateData); + vn_encode_VkBool32(enc, &val->shaderDemoteToHelperInvocation); + vn_encode_VkBool32(enc, &val->shaderTerminateInvocation); + vn_encode_VkBool32(enc, &val->subgroupSizeControl); + vn_encode_VkBool32(enc, &val->computeFullSubgroups); + vn_encode_VkBool32(enc, &val->synchronization2); + vn_encode_VkBool32(enc, &val->textureCompressionASTC_HDR); + vn_encode_VkBool32(enc, &val->shaderZeroInitializeWorkgroupMemory); + vn_encode_VkBool32(enc, &val->dynamicRendering); + vn_encode_VkBool32(enc, &val->shaderIntegerDotProduct); + vn_encode_VkBool32(enc, &val->maintenance4); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES }); + vn_encode_VkPhysicalDeviceVulkan13Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->robustImageAccess); + vn_decode_VkBool32(dec, &val->inlineUniformBlock); + vn_decode_VkBool32(dec, &val->descriptorBindingInlineUniformBlockUpdateAfterBind); + vn_decode_VkBool32(dec, &val->pipelineCreationCacheControl); + vn_decode_VkBool32(dec, &val->privateData); + vn_decode_VkBool32(dec, &val->shaderDemoteToHelperInvocation); + vn_decode_VkBool32(dec, &val->shaderTerminateInvocation); + vn_decode_VkBool32(dec, &val->subgroupSizeControl); + vn_decode_VkBool32(dec, &val->computeFullSubgroups); + vn_decode_VkBool32(dec, &val->synchronization2); + vn_decode_VkBool32(dec, &val->textureCompressionASTC_HDR); + vn_decode_VkBool32(dec, &val->shaderZeroInitializeWorkgroupMemory); + vn_decode_VkBool32(dec, &val->dynamicRendering); + vn_decode_VkBool32(dec, &val->shaderIntegerDotProduct); + vn_decode_VkBool32(dec, &val->maintenance4); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan13Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkan13Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkan13Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(const VkPhysicalDeviceVulkan13Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->robustImageAccess */ + /* skip val->inlineUniformBlock */ + /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */ + /* skip val->pipelineCreationCacheControl */ + /* skip val->privateData */ + /* skip val->shaderDemoteToHelperInvocation */ + /* skip val->shaderTerminateInvocation */ + /* skip val->subgroupSizeControl */ + /* skip val->computeFullSubgroups */ + /* skip val->synchronization2 */ + /* skip val->textureCompressionASTC_HDR */ + /* skip val->shaderZeroInitializeWorkgroupMemory */ + /* skip val->dynamicRendering */ + /* skip val->shaderIntegerDotProduct */ + /* skip val->maintenance4 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Features_partial(const VkPhysicalDeviceVulkan13Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->robustImageAccess */ + /* skip val->inlineUniformBlock */ + /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */ + /* skip val->pipelineCreationCacheControl */ + /* skip val->privateData */ + /* skip val->shaderDemoteToHelperInvocation */ + /* skip val->shaderTerminateInvocation */ + /* skip val->subgroupSizeControl */ + /* skip val->computeFullSubgroups */ + /* skip val->synchronization2 */ + /* skip val->textureCompressionASTC_HDR */ + /* skip val->shaderZeroInitializeWorkgroupMemory */ + /* skip val->dynamicRendering */ + /* skip val->shaderIntegerDotProduct */ + /* skip val->maintenance4 */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES }); + vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->extendedDynamicState); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->extendedDynamicState); +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->extendedDynamicState); +} + +static inline void +vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->extendedDynamicState */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->extendedDynamicState */ +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->extendedDynamicState2); + size += vn_sizeof_VkBool32(&val->extendedDynamicState2LogicOp); + size += vn_sizeof_VkBool32(&val->extendedDynamicState2PatchControlPoints); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->extendedDynamicState2); + vn_encode_VkBool32(enc, &val->extendedDynamicState2LogicOp); + vn_encode_VkBool32(enc, &val->extendedDynamicState2PatchControlPoints); +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->extendedDynamicState2); + vn_decode_VkBool32(dec, &val->extendedDynamicState2LogicOp); + vn_decode_VkBool32(dec, &val->extendedDynamicState2PatchControlPoints); +} + +static inline void +vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->extendedDynamicState2 */ + /* skip val->extendedDynamicState2LogicOp */ + /* skip val->extendedDynamicState2PatchControlPoints */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->extendedDynamicState2 */ + /* skip val->extendedDynamicState2LogicOp */ + /* skip val->extendedDynamicState2PatchControlPoints */ +} + +static inline void +vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderZeroInitializeWorkgroupMemory); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderZeroInitializeWorkgroupMemory); +} + +static inline void +vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES }); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderZeroInitializeWorkgroupMemory); +} + +static inline void +vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderZeroInitializeWorkgroupMemory */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderZeroInitializeWorkgroupMemory */ +} + +static inline void +vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES }); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceImageRobustnessFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->robustImageAccess); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->robustImageAccess); +} + +static inline void +vn_encode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES }); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImageRobustnessFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->robustImageAccess); +} + +static inline void +vn_decode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImageRobustnessFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->robustImageAccess */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_partial(const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->robustImageAccess */ +} + +static inline void +vn_encode_VkPhysicalDeviceImageRobustnessFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES }); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDevice4444FormatsFeaturesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->formatA4R4G4B4); + size += vn_sizeof_VkBool32(&val->formatA4B4G4R4); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->formatA4R4G4B4); + vn_encode_VkBool32(enc, &val->formatA4B4G4R4); +} + +static inline void +vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT }); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->formatA4R4G4B4); + vn_decode_VkBool32(dec, &val->formatA4B4G4R4); +} + +static inline void +vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->formatA4R4G4B4 */ + /* skip val->formatA4B4G4R4 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_partial(const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->formatA4R4G4B4 */ + /* skip val->formatA4B4G4R4 */ +} + +static inline void +vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT }); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderTerminateInvocationFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderTerminateInvocation); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderTerminateInvocation); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES }); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderTerminateInvocation); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderTerminateInvocation */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderTerminateInvocation */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES }); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSynchronization2Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(const VkPhysicalDeviceSynchronization2Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->synchronization2); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->synchronization2); +} + +static inline void +vn_encode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES }); + vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSynchronization2Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->synchronization2); +} + +static inline void +vn_decode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_decoder *dec, VkPhysicalDeviceSynchronization2Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSynchronization2Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(const VkPhysicalDeviceSynchronization2Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->synchronization2 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSynchronization2Features_partial(const VkPhysicalDeviceSynchronization2Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->synchronization2 */ +} + +static inline void +vn_encode_VkPhysicalDeviceSynchronization2Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES }); + vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->ycbcr2plane444Formats); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->ycbcr2plane444Formats); +} + +static inline void +vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->ycbcr2plane444Formats); +} + +static inline void +vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->ycbcr2plane444Formats */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->ycbcr2plane444Formats */ +} + +static inline void +vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderIntegerDotProductFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderIntegerDotProduct); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderIntegerDotProduct); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES }); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderIntegerDotProduct); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderIntegerDotProduct */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderIntegerDotProduct */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES }); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceDynamicRenderingFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->dynamicRendering); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->dynamicRendering); +} + +static inline void +vn_encode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES }); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->dynamicRendering); +} + +static inline void +vn_decode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->dynamicRendering */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_partial(const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->dynamicRendering */ +} + +static inline void +vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES }); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(enc, val); +} + /* struct VkPhysicalDeviceFeatures2 chain */ static inline size_t @@ -4585,6 +7222,12 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val) while (pnext) { switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self((const VkPhysicalDevicePrivateDataFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -4621,6 +7264,18 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val) size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -4699,12 +7354,42 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val) size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -4717,6 +7402,72 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val) size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self((const VkPhysicalDeviceVulkan13Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self((const VkPhysicalDeviceImageRobustnessFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self((const VkPhysicalDeviceSynchronization2Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -4755,6 +7506,12 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void while (pnext) { switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -4791,6 +7548,18 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -4869,12 +7638,42 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -4887,6 +7686,72 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, (const VkPhysicalDeviceVulkan13Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + return; default: /* ignore unknown/unsupported struct */ break; @@ -4930,6 +7795,10 @@ vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void } switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDevicePrivateDataFeatures_self(dec, (VkPhysicalDevicePrivateDataFeatures *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext); @@ -4954,6 +7823,14 @@ vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(dec, (VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, (VkPhysicalDeviceMaintenance4Features *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); @@ -5006,10 +7883,30 @@ vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(dec, (VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(dec, (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(dec, (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(dec, (VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(dec, (VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext); @@ -5018,6 +7915,50 @@ vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkan13Features_self(dec, (VkPhysicalDeviceVulkan13Features *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(dec, (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(dec, (VkPhysicalDeviceImageRobustnessFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(dec, (VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(dec, (VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSynchronization2Features_self(dec, (VkPhysicalDeviceSynchronization2Features *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(dec, (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(dec, (VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(dec, (VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + break; default: assert(false); break; @@ -5051,6 +7992,12 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val) while (pnext) { switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial((const VkPhysicalDevicePrivateDataFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -5087,6 +8034,18 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val) size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial((const VkPhysicalDeviceMaintenance4Features *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -5165,12 +8124,42 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val) size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -5183,6 +8172,72 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val) size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial((const VkPhysicalDeviceVulkan13Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial((const VkPhysicalDeviceImageRobustnessFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial((const VkPhysicalDeviceSynchronization2Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -5221,6 +8276,12 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, con while (pnext) { switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -5257,6 +8318,18 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, con vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -5335,12 +8408,42 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, con vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -5353,6 +8456,72 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, con vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(enc, (const VkPhysicalDeviceVulkan13Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + return; default: /* ignore unknown/unsupported struct */ break; @@ -5456,6 +8625,18 @@ vn_sizeof_VkDeviceCreateInfo_pnext(const void *val) while (pnext) { switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDevicePrivateDataCreateInfo_self((const VkDevicePrivateDataCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self((const VkPhysicalDevicePrivateDataFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -5504,6 +8685,18 @@ vn_sizeof_VkDeviceCreateInfo_pnext(const void *val) size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -5582,12 +8775,42 @@ vn_sizeof_VkDeviceCreateInfo_pnext(const void *val) size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -5600,6 +8823,72 @@ vn_sizeof_VkDeviceCreateInfo_pnext(const void *val) size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self((const VkPhysicalDeviceVulkan13Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self((const VkPhysicalDeviceImageRobustnessFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self((const VkPhysicalDeviceSynchronization2Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -5671,6 +8960,18 @@ vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) while (pnext) { switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkDevicePrivateDataCreateInfo_self(enc, (const VkDevicePrivateDataCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -5719,6 +9020,18 @@ vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -5797,12 +9110,42 @@ vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -5815,6 +9158,72 @@ vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, (const VkPhysicalDeviceVulkan13Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext); + return; default: /* ignore unknown/unsupported struct */ break; @@ -6739,6 +10148,130 @@ vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_enc vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val); } +/* struct VkPhysicalDeviceInlineUniformBlockProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(const VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockSize); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->maxInlineUniformBlockSize); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxDescriptorSetInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks); +} + +static inline void +vn_decode_VkPhysicalDeviceInlineUniformBlockProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(const VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxInlineUniformBlockSize */ + /* skip val->maxPerStageDescriptorInlineUniformBlocks */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */ + /* skip val->maxDescriptorSetInlineUniformBlocks */ + /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_partial(const VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxInlineUniformBlockSize */ + /* skip val->maxPerStageDescriptorInlineUniformBlocks */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */ + /* skip val->maxDescriptorSetInlineUniformBlocks */ + /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */ +} + +static inline void +vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES }); + vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(enc, val); +} + /* struct VkPhysicalDeviceMaintenance3Properties chain */ static inline size_t @@ -6851,6 +10384,114 @@ vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *e vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val); } +/* struct VkPhysicalDeviceMaintenance4Properties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(const VkPhysicalDeviceMaintenance4Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceSize(&val->maxBufferSize); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance4Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Properties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkDeviceSize(dec, &val->maxBufferSize); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance4Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Properties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(const VkPhysicalDeviceMaintenance4Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxBufferSize */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance4Properties_partial(const VkPhysicalDeviceMaintenance4Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Properties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxBufferSize */ +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance4Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Properties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES }); + vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, val); +} + /* struct VkPhysicalDeviceFloatControlsProperties chain */ static inline size_t @@ -7591,6 +11232,246 @@ vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_en vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val); } +/* struct VkPhysicalDeviceTexelBufferAlignmentProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(const VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceSize(&val->storageTexelBufferOffsetAlignmentBytes); + size += vn_sizeof_VkBool32(&val->storageTexelBufferOffsetSingleTexelAlignment); + size += vn_sizeof_VkDeviceSize(&val->uniformTexelBufferOffsetAlignmentBytes); + size += vn_sizeof_VkBool32(&val->uniformTexelBufferOffsetSingleTexelAlignment); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkDeviceSize(dec, &val->storageTexelBufferOffsetAlignmentBytes); + vn_decode_VkBool32(dec, &val->storageTexelBufferOffsetSingleTexelAlignment); + vn_decode_VkDeviceSize(dec, &val->uniformTexelBufferOffsetAlignmentBytes); + vn_decode_VkBool32(dec, &val->uniformTexelBufferOffsetSingleTexelAlignment); +} + +static inline void +vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->storageTexelBufferOffsetAlignmentBytes */ + /* skip val->storageTexelBufferOffsetSingleTexelAlignment */ + /* skip val->uniformTexelBufferOffsetAlignmentBytes */ + /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->storageTexelBufferOffsetAlignmentBytes */ + /* skip val->storageTexelBufferOffsetSingleTexelAlignment */ + /* skip val->uniformTexelBufferOffsetAlignmentBytes */ + /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */ +} + +static inline void +vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES }); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSubgroupSizeControlProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(const VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->minSubgroupSize); + size += vn_sizeof_uint32_t(&val->maxSubgroupSize); + size += vn_sizeof_uint32_t(&val->maxComputeWorkgroupSubgroups); + size += vn_sizeof_VkFlags(&val->requiredSubgroupSizeStages); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->minSubgroupSize); + vn_decode_uint32_t(dec, &val->maxSubgroupSize); + vn_decode_uint32_t(dec, &val->maxComputeWorkgroupSubgroups); + vn_decode_VkFlags(dec, &val->requiredSubgroupSizeStages); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(const VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->minSubgroupSize */ + /* skip val->maxSubgroupSize */ + /* skip val->maxComputeWorkgroupSubgroups */ + /* skip val->requiredSubgroupSizeStages */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_partial(const VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->minSubgroupSize */ + /* skip val->maxSubgroupSize */ + /* skip val->maxComputeWorkgroupSubgroups */ + /* skip val->requiredSubgroupSizeStages */ +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES }); + vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(enc, val); +} + /* struct VkPhysicalDeviceVulkan11Properties chain */ static inline size_t @@ -8087,6 +11968,514 @@ vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val); } +/* struct VkPhysicalDeviceVulkan13Properties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(const VkPhysicalDeviceVulkan13Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->minSubgroupSize); + size += vn_sizeof_uint32_t(&val->maxSubgroupSize); + size += vn_sizeof_uint32_t(&val->maxComputeWorkgroupSubgroups); + size += vn_sizeof_VkFlags(&val->requiredSubgroupSizeStages); + size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockSize); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks); + size += vn_sizeof_uint32_t(&val->maxInlineUniformTotalSize); + size += vn_sizeof_VkBool32(&val->integerDotProduct8BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct8BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct8BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct16BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct16BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct16BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct32BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct32BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct32BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct64BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct64BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct64BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated); + size += vn_sizeof_VkDeviceSize(&val->storageTexelBufferOffsetAlignmentBytes); + size += vn_sizeof_VkBool32(&val->storageTexelBufferOffsetSingleTexelAlignment); + size += vn_sizeof_VkDeviceSize(&val->uniformTexelBufferOffsetAlignmentBytes); + size += vn_sizeof_VkBool32(&val->uniformTexelBufferOffsetSingleTexelAlignment); + size += vn_sizeof_VkDeviceSize(&val->maxBufferSize); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan13Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Properties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->minSubgroupSize); + vn_decode_uint32_t(dec, &val->maxSubgroupSize); + vn_decode_uint32_t(dec, &val->maxComputeWorkgroupSubgroups); + vn_decode_VkFlags(dec, &val->requiredSubgroupSizeStages); + vn_decode_uint32_t(dec, &val->maxInlineUniformBlockSize); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxDescriptorSetInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks); + vn_decode_uint32_t(dec, &val->maxInlineUniformTotalSize); + vn_decode_VkBool32(dec, &val->integerDotProduct8BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct8BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct8BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct16BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct16BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct16BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct32BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct32BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct32BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct64BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct64BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct64BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated); + vn_decode_VkDeviceSize(dec, &val->storageTexelBufferOffsetAlignmentBytes); + vn_decode_VkBool32(dec, &val->storageTexelBufferOffsetSingleTexelAlignment); + vn_decode_VkDeviceSize(dec, &val->uniformTexelBufferOffsetAlignmentBytes); + vn_decode_VkBool32(dec, &val->uniformTexelBufferOffsetSingleTexelAlignment); + vn_decode_VkDeviceSize(dec, &val->maxBufferSize); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan13Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Properties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkan13Properties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(const VkPhysicalDeviceVulkan13Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->minSubgroupSize */ + /* skip val->maxSubgroupSize */ + /* skip val->maxComputeWorkgroupSubgroups */ + /* skip val->requiredSubgroupSizeStages */ + /* skip val->maxInlineUniformBlockSize */ + /* skip val->maxPerStageDescriptorInlineUniformBlocks */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */ + /* skip val->maxDescriptorSetInlineUniformBlocks */ + /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */ + /* skip val->maxInlineUniformTotalSize */ + /* skip val->integerDotProduct8BitUnsignedAccelerated */ + /* skip val->integerDotProduct8BitSignedAccelerated */ + /* skip val->integerDotProduct8BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProduct16BitUnsignedAccelerated */ + /* skip val->integerDotProduct16BitSignedAccelerated */ + /* skip val->integerDotProduct16BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct32BitUnsignedAccelerated */ + /* skip val->integerDotProduct32BitSignedAccelerated */ + /* skip val->integerDotProduct32BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct64BitUnsignedAccelerated */ + /* skip val->integerDotProduct64BitSignedAccelerated */ + /* skip val->integerDotProduct64BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */ + /* skip val->storageTexelBufferOffsetAlignmentBytes */ + /* skip val->storageTexelBufferOffsetSingleTexelAlignment */ + /* skip val->uniformTexelBufferOffsetAlignmentBytes */ + /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */ + /* skip val->maxBufferSize */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan13Properties_partial(const VkPhysicalDeviceVulkan13Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Properties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->minSubgroupSize */ + /* skip val->maxSubgroupSize */ + /* skip val->maxComputeWorkgroupSubgroups */ + /* skip val->requiredSubgroupSizeStages */ + /* skip val->maxInlineUniformBlockSize */ + /* skip val->maxPerStageDescriptorInlineUniformBlocks */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */ + /* skip val->maxDescriptorSetInlineUniformBlocks */ + /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */ + /* skip val->maxInlineUniformTotalSize */ + /* skip val->integerDotProduct8BitUnsignedAccelerated */ + /* skip val->integerDotProduct8BitSignedAccelerated */ + /* skip val->integerDotProduct8BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProduct16BitUnsignedAccelerated */ + /* skip val->integerDotProduct16BitSignedAccelerated */ + /* skip val->integerDotProduct16BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct32BitUnsignedAccelerated */ + /* skip val->integerDotProduct32BitSignedAccelerated */ + /* skip val->integerDotProduct32BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct64BitUnsignedAccelerated */ + /* skip val->integerDotProduct64BitSignedAccelerated */ + /* skip val->integerDotProduct64BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */ + /* skip val->storageTexelBufferOffsetAlignmentBytes */ + /* skip val->storageTexelBufferOffsetSingleTexelAlignment */ + /* skip val->uniformTexelBufferOffsetAlignmentBytes */ + /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */ + /* skip val->maxBufferSize */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan13Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Properties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES }); + vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderIntegerDotProductProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(const VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->integerDotProduct8BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct8BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct8BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct16BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct16BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct16BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct32BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct32BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct32BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct64BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct64BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProduct64BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitSignedAccelerated); + size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->integerDotProduct8BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct8BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct8BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct16BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct16BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct16BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct32BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct32BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct32BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct64BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct64BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProduct64BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitSignedAccelerated); + vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->integerDotProduct8BitUnsignedAccelerated */ + /* skip val->integerDotProduct8BitSignedAccelerated */ + /* skip val->integerDotProduct8BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProduct16BitUnsignedAccelerated */ + /* skip val->integerDotProduct16BitSignedAccelerated */ + /* skip val->integerDotProduct16BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct32BitUnsignedAccelerated */ + /* skip val->integerDotProduct32BitSignedAccelerated */ + /* skip val->integerDotProduct32BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct64BitUnsignedAccelerated */ + /* skip val->integerDotProduct64BitSignedAccelerated */ + /* skip val->integerDotProduct64BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->integerDotProduct8BitUnsignedAccelerated */ + /* skip val->integerDotProduct8BitSignedAccelerated */ + /* skip val->integerDotProduct8BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProduct16BitUnsignedAccelerated */ + /* skip val->integerDotProduct16BitSignedAccelerated */ + /* skip val->integerDotProduct16BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct32BitUnsignedAccelerated */ + /* skip val->integerDotProduct32BitSignedAccelerated */ + /* skip val->integerDotProduct32BitMixedSignednessAccelerated */ + /* skip val->integerDotProduct64BitUnsignedAccelerated */ + /* skip val->integerDotProduct64BitSignedAccelerated */ + /* skip val->integerDotProduct64BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */ + /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES }); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(enc, val); +} + /* struct VkPhysicalDeviceProperties2 chain */ static inline size_t @@ -8139,12 +12528,24 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val) size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self((const VkPhysicalDeviceInlineUniformBlockProperties *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self((const VkPhysicalDeviceMaintenance4Properties *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -8175,6 +12576,18 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val) size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self((const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self((const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -8187,6 +12600,18 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val) size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self((const VkPhysicalDeviceVulkan13Properties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self((const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -8263,10 +12688,18 @@ vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const voi vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(dec, (VkPhysicalDeviceInlineUniformBlockProperties *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, (VkPhysicalDeviceMaintenance4Properties *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext); @@ -8287,6 +12720,14 @@ vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const voi vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(dec, (VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(dec, (VkPhysicalDeviceSubgroupSizeControlProperties *)pnext); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext); @@ -8295,6 +12736,14 @@ vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const voi vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkan13Properties_self(dec, (VkPhysicalDeviceVulkan13Properties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(dec, (VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext); + break; default: assert(false); break; @@ -8370,12 +12819,24 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val) size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial((const VkPhysicalDeviceInlineUniformBlockProperties *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial((const VkPhysicalDeviceMaintenance4Properties *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -8406,6 +12867,18 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val) size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial((const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial((const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext); + return size; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: size += vn_sizeof_simple_pointer(pnext); size += vn_sizeof_VkStructureType(&pnext->sType); @@ -8418,6 +12891,18 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val) size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext); return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial((const VkPhysicalDeviceVulkan13Properties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial((const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -8498,12 +12983,24 @@ vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, c vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(enc, (const VkPhysicalDeviceInlineUniformBlockProperties *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance4Properties *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -8534,6 +13031,18 @@ vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, c vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(enc, (const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext); + return; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: vn_encode_simple_pointer(enc, pnext); vn_encode_VkStructureType(enc, &pnext->sType); @@ -8546,6 +13055,18 @@ vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, c vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(enc, (const VkPhysicalDeviceVulkan13Properties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(enc, (const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext); + return; default: /* ignore unknown/unsupported struct */ break; @@ -8747,6 +13268,297 @@ vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val); } +/* struct VkFormatProperties3 chain */ + +static inline size_t +vn_sizeof_VkFormatProperties3_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFormatProperties3_self(const VkFormatProperties3 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags64(&val->linearTilingFeatures); + size += vn_sizeof_VkFlags64(&val->optimalTilingFeatures); + size += vn_sizeof_VkFlags64(&val->bufferFeatures); + return size; +} + +static inline size_t +vn_sizeof_VkFormatProperties3(const VkFormatProperties3 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFormatProperties3_pnext(val->pNext); + size += vn_sizeof_VkFormatProperties3_self(val); + + return size; +} + +static inline void +vn_decode_VkFormatProperties3_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkFormatProperties3_self(struct vn_cs_decoder *dec, VkFormatProperties3 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags64(dec, &val->linearTilingFeatures); + vn_decode_VkFlags64(dec, &val->optimalTilingFeatures); + vn_decode_VkFlags64(dec, &val->bufferFeatures); +} + +static inline void +vn_decode_VkFormatProperties3(struct vn_cs_decoder *dec, VkFormatProperties3 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3); + + assert(val->sType == stype); + vn_decode_VkFormatProperties3_pnext(dec, val->pNext); + vn_decode_VkFormatProperties3_self(dec, val); +} + +static inline size_t +vn_sizeof_VkFormatProperties3_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFormatProperties3_self_partial(const VkFormatProperties3 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->linearTilingFeatures */ + /* skip val->optimalTilingFeatures */ + /* skip val->bufferFeatures */ + return size; +} + +static inline size_t +vn_sizeof_VkFormatProperties3_partial(const VkFormatProperties3 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFormatProperties3_pnext_partial(val->pNext); + size += vn_sizeof_VkFormatProperties3_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkFormatProperties3_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkFormatProperties3_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties3 *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->linearTilingFeatures */ + /* skip val->optimalTilingFeatures */ + /* skip val->bufferFeatures */ +} + +static inline void +vn_encode_VkFormatProperties3_partial(struct vn_cs_encoder *enc, const VkFormatProperties3 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 }); + vn_encode_VkFormatProperties3_pnext_partial(enc, val->pNext); + vn_encode_VkFormatProperties3_self_partial(enc, val); +} + +/* struct VkDrmFormatModifierProperties2EXT */ + +static inline size_t +vn_sizeof_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT *val) +{ + size_t size = 0; + size += vn_sizeof_uint64_t(&val->drmFormatModifier); + size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount); + size += vn_sizeof_VkFlags64(&val->drmFormatModifierTilingFeatures); + return size; +} + +static inline void +vn_decode_VkDrmFormatModifierProperties2EXT(struct vn_cs_decoder *dec, VkDrmFormatModifierProperties2EXT *val) +{ + vn_decode_uint64_t(dec, &val->drmFormatModifier); + vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount); + vn_decode_VkFlags64(dec, &val->drmFormatModifierTilingFeatures); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(const VkDrmFormatModifierProperties2EXT *val) +{ + size_t size = 0; + /* skip val->drmFormatModifier */ + /* skip val->drmFormatModifierPlaneCount */ + /* skip val->drmFormatModifierTilingFeatures */ + return size; +} + +static inline void +vn_encode_VkDrmFormatModifierProperties2EXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierProperties2EXT *val) +{ + /* skip val->drmFormatModifier */ + /* skip val->drmFormatModifierPlaneCount */ + /* skip val->drmFormatModifierTilingFeatures */ +} + +/* struct VkDrmFormatModifierPropertiesList2EXT chain */ + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(const VkDrmFormatModifierPropertiesList2EXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->drmFormatModifierCount); + if (val->pDrmFormatModifierProperties) { + size += vn_sizeof_array_size(val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + size += vn_sizeof_VkDrmFormatModifierProperties2EXT(&val->pDrmFormatModifierProperties[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(val->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(val); + + return size; +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesList2EXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->drmFormatModifierCount); + if (vn_peek_array_size(dec)) { + const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount); + for (uint32_t i = 0; i < iter_count; i++) + vn_decode_VkDrmFormatModifierProperties2EXT(dec, &val->pDrmFormatModifierProperties[i]); + } else { + vn_decode_array_size_unchecked(dec); + val->pDrmFormatModifierProperties = NULL; + } +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesList2EXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesList2EXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT); + + assert(val->sType == stype); + vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(dec, val->pNext); + vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(const VkDrmFormatModifierPropertiesList2EXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* WA1: size += vn_sizeof_uint32_t(&val->drmFormatModifierCount) */(void)0; + if (val->pDrmFormatModifierProperties) { + size += vn_sizeof_array_size(val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + size += vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(&val->pDrmFormatModifierProperties[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_partial(const VkDrmFormatModifierPropertiesList2EXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(val->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesList2EXT *val) +{ + /* skip val->{sType,pNext} */ + /* WA1: vn_encode_uint32_t(enc, &val->drmFormatModifierCount) */(void)0; + if (val->pDrmFormatModifierProperties) { + vn_encode_array_size(enc, val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + vn_encode_VkDrmFormatModifierProperties2EXT_partial(enc, &val->pDrmFormatModifierProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesList2EXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesList2EXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT }); + vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(enc, val->pNext); + vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(enc, val); +} + /* struct VkFormatProperties2 chain */ static inline size_t @@ -8763,6 +13575,18 @@ vn_sizeof_VkFormatProperties2_pnext(const void *val) size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext); size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext); return size; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkFormatProperties3_self((const VkFormatProperties3 *)pnext); + return size; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self((const VkDrmFormatModifierPropertiesList2EXT *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -8815,6 +13639,14 @@ vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val) vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext); vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext); break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext); + vn_decode_VkFormatProperties3_self(dec, (VkFormatProperties3 *)pnext); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext); + vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(dec, (VkDrmFormatModifierPropertiesList2EXT *)pnext); + break; default: assert(false); break; @@ -8854,6 +13686,18 @@ vn_sizeof_VkFormatProperties2_pnext_partial(const void *val) size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext); size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext); return size; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkFormatProperties3_self_partial((const VkFormatProperties3 *)pnext); + return size; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial((const VkDrmFormatModifierPropertiesList2EXT *)pnext); + return size; default: /* ignore unknown/unsupported struct */ break; @@ -8898,6 +13742,18 @@ vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const voi vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext); vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext); return; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkFormatProperties3_self_partial(enc, (const VkFormatProperties3 *)pnext); + return; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(enc, (const VkDrmFormatModifierPropertiesList2EXT *)pnext); + return; default: /* ignore unknown/unsupported struct */ break; @@ -10733,6 +15589,146 @@ vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 vn_encode_VkDeviceQueueInfo2_self(enc, val); } +/* struct VkPhysicalDeviceToolProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceToolProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceToolProperties_self(const VkPhysicalDeviceToolProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_char_array(val->name, VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_char_array(val->version, VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_VkFlags(&val->purposes); + size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE); + size += vn_sizeof_char_array(val->description, VK_MAX_DESCRIPTION_SIZE); + size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_char_array(val->layer, VK_MAX_EXTENSION_NAME_SIZE); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceToolProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceToolProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceToolProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceToolProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceToolProperties *val) +{ + /* skip val->{sType,pNext} */ + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE); + vn_decode_char_array(dec, val->name, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE); + vn_decode_char_array(dec, val->version, array_size); + } + vn_decode_VkFlags(dec, &val->purposes); + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE); + vn_decode_char_array(dec, val->description, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE); + vn_decode_char_array(dec, val->layer, array_size); + } +} + +static inline void +vn_decode_VkPhysicalDeviceToolProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceToolProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceToolProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceToolProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(const VkPhysicalDeviceToolProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->name */ + /* skip val->version */ + /* skip val->purposes */ + /* skip val->description */ + /* skip val->layer */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceToolProperties_partial(const VkPhysicalDeviceToolProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceToolProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceToolProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->name */ + /* skip val->version */ + /* skip val->purposes */ + /* skip val->description */ + /* skip val->layer */ +} + +static inline void +vn_encode_VkPhysicalDeviceToolProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceToolProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES }); + vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceToolProperties_self_partial(enc, val); +} + static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT; @@ -12562,6 +17558,94 @@ static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, } } +static inline size_t vn_sizeof_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pToolCount); + if (pToolCount) + cmd_size += vn_sizeof_uint32_t(pToolCount); + if (pToolProperties) { + cmd_size += vn_sizeof_array_size((pToolCount ? *pToolCount : 0)); + for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++) + cmd_size += vn_sizeof_VkPhysicalDeviceToolProperties_partial(&pToolProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceToolProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pToolCount)) + vn_encode_uint32_t(enc, pToolCount); + if (pToolProperties) { + vn_encode_array_size(enc, (pToolCount ? *pToolCount : 0)); + for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++) + vn_encode_VkPhysicalDeviceToolProperties_partial(enc, &pToolProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pToolCount); + if (pToolCount) + cmd_size += vn_sizeof_uint32_t(pToolCount); + if (pToolProperties) { + cmd_size += vn_sizeof_array_size((pToolCount ? *pToolCount : 0)); + for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++) + cmd_size += vn_sizeof_VkPhysicalDeviceToolProperties(&pToolProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetPhysicalDeviceToolProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pToolCount); + } else { + pToolCount = NULL; + } + if (vn_peek_array_size(dec)) { + const uint32_t iter_count = vn_decode_array_size(dec, (pToolCount ? *pToolCount : 0)); + for (uint32_t i = 0; i < iter_count; i++) + vn_decode_VkPhysicalDeviceToolProperties(dec, &pToolProperties[i]); + } else { + vn_decode_array_size_unchecked(dec); + pToolProperties = NULL; + } + + return ret; +} + static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_instance_submit_command *submit) { uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; @@ -13129,6 +18213,27 @@ static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, } } +static inline void vn_submit_vkGetPhysicalDeviceToolProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(physicalDevice, pToolCount, pToolProperties) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkGetPhysicalDeviceToolProperties(enc, cmd_flags, physicalDevice, pToolCount, pToolProperties); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { VN_TRACE_FUNC(); @@ -13666,4 +18771,26 @@ static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, V vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit); } +static inline VkResult vn_call_vkGetPhysicalDeviceToolProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceToolProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pToolCount, pToolProperties, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + const VkResult ret = vn_decode_vkGetPhysicalDeviceToolProperties_reply(dec, physicalDevice, pToolCount, pToolProperties); + vn_instance_free_command_reply(vn_instance, &submit); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetPhysicalDeviceToolProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceToolProperties(vn_instance, 0, physicalDevice, pToolCount, pToolProperties, &submit); +} + #endif /* VN_PROTOCOL_DRIVER_DEVICE_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_handles.h b/src/virtio/venus-protocol/vn_protocol_driver_handles.h index b837b285c83..7b4b6d8a4d2 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_handles.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_handles.h @@ -631,4 +631,27 @@ vn_decode_VkSamplerYcbcrConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrConv vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION); } +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) */ + +static inline size_t +vn_sizeof_VkPrivateDataSlot(const VkPrivateDataSlot *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkPrivateDataSlot(struct vn_cs_encoder *enc, const VkPrivateDataSlot *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkPrivateDataSlot(struct vn_cs_decoder *dec, VkPrivateDataSlot *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT); +} + #endif /* VN_PROTOCOL_DRIVER_HANDLES_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_image.h b/src/virtio/venus-protocol/vn_protocol_driver_image.h index 99339879dbd..dcca3b2422d 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_image.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_image.h @@ -110,6 +110,33 @@ vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExt vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val); } +static inline void +vn_decode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_decoder *dec, VkExternalMemoryImageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->handleTypes); +} + +static inline void +vn_decode_VkExternalMemoryImageCreateInfo(struct vn_cs_decoder *dec, VkExternalMemoryImageCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkExternalMemoryImageCreateInfo_pnext(dec, val->pNext); + vn_decode_VkExternalMemoryImageCreateInfo_self(dec, val); +} + /* struct VkImageDrmFormatModifierListCreateInfoEXT chain */ static inline size_t @@ -175,6 +202,40 @@ vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, c vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val); } +static inline void +vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierListCreateInfoEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->drmFormatModifierCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->drmFormatModifierCount); + vn_decode_uint64_t_array(dec, (uint64_t *)val->pDrmFormatModifiers, array_size); + } else { + vn_decode_array_size_unchecked(dec); + val->pDrmFormatModifiers = NULL; + } +} + +static inline void +vn_decode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierListCreateInfoEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT); + + assert(val->sType == stype); + vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(dec, val->pNext); + vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self(dec, val); +} + /* struct VkSubresourceLayout */ static inline size_t @@ -300,6 +361,42 @@ vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *en vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val); } +static inline void +vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierExplicitCreateInfoEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint64_t(dec, &val->drmFormatModifier); + vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount); + if (vn_peek_array_size(dec)) { + const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierPlaneCount); + for (uint32_t i = 0; i < iter_count; i++) + vn_decode_VkSubresourceLayout(dec, &((VkSubresourceLayout *)val->pPlaneLayouts)[i]); + } else { + vn_decode_array_size_unchecked(dec); + val->pPlaneLayouts = NULL; + } +} + +static inline void +vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierExplicitCreateInfoEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT); + + assert(val->sType == stype); + vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(dec, val->pNext); + vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(dec, val); +} + /* struct VkImageCreateInfo chain */ static inline size_t @@ -468,6 +565,86 @@ vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo * vn_encode_VkImageCreateInfo_self(enc, val); } +static inline void +vn_decode_VkImageCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkExternalMemoryImageCreateInfo_self(dec, (VkExternalMemoryImageCreateInfo *)pnext); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkImageFormatListCreateInfo_self(dec, (VkImageFormatListCreateInfo *)pnext); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self(dec, (VkImageDrmFormatModifierListCreateInfoEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(dec, (VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext); + vn_decode_VkImageStencilUsageCreateInfo_self(dec, (VkImageStencilUsageCreateInfo *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkImageCreateInfo_self(struct vn_cs_decoder *dec, VkImageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->flags); + vn_decode_VkImageType(dec, &val->imageType); + vn_decode_VkFormat(dec, &val->format); + vn_decode_VkExtent3D(dec, &val->extent); + vn_decode_uint32_t(dec, &val->mipLevels); + vn_decode_uint32_t(dec, &val->arrayLayers); + vn_decode_VkSampleCountFlagBits(dec, &val->samples); + vn_decode_VkImageTiling(dec, &val->tiling); + vn_decode_VkFlags(dec, &val->usage); + vn_decode_VkSharingMode(dec, &val->sharingMode); + vn_decode_uint32_t(dec, &val->queueFamilyIndexCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->queueFamilyIndexCount); + vn_decode_uint32_t_array(dec, (uint32_t *)val->pQueueFamilyIndices, array_size); + } else { + vn_decode_array_size_unchecked(dec); + val->pQueueFamilyIndices = NULL; + } + vn_decode_VkImageLayout(dec, &val->initialLayout); +} + +static inline void +vn_decode_VkImageCreateInfo(struct vn_cs_decoder *dec, VkImageCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkImageCreateInfo_pnext(dec, val->pNext); + vn_decode_VkImageCreateInfo_self(dec, val); +} + /* struct VkBindImageMemoryDeviceGroupInfo chain */ static inline size_t @@ -1126,6 +1303,64 @@ vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, co vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val); } +/* struct VkDeviceImageMemoryRequirements chain */ + +static inline size_t +vn_sizeof_VkDeviceImageMemoryRequirements_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceImageMemoryRequirements_self(const VkDeviceImageMemoryRequirements *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_simple_pointer(val->pCreateInfo); + if (val->pCreateInfo) + size += vn_sizeof_VkImageCreateInfo(val->pCreateInfo); + size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceImageMemoryRequirements_pnext(val->pNext); + size += vn_sizeof_VkDeviceImageMemoryRequirements_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceImageMemoryRequirements_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceImageMemoryRequirements_self(struct vn_cs_encoder *enc, const VkDeviceImageMemoryRequirements *val) +{ + /* skip val->{sType,pNext} */ + if (vn_encode_simple_pointer(enc, val->pCreateInfo)) + vn_encode_VkImageCreateInfo(enc, val->pCreateInfo); + vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect); +} + +static inline void +vn_encode_VkDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, const VkDeviceImageMemoryRequirements *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS }); + vn_encode_VkDeviceImageMemoryRequirements_pnext(enc, val->pNext); + vn_encode_VkDeviceImageMemoryRequirements_self(enc, val); +} + /* struct VkImageDrmFormatModifierPropertiesEXT chain */ static inline size_t @@ -1838,6 +2073,155 @@ static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn } } +static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo); + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo); + if (vn_encode_simple_pointer(enc, pMemoryRequirements)) + vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements); +} + +static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pInfo */ + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT); + + /* skip device */ + /* skip pInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements); + } else { + pMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo); + cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirementCount) + cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); + for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) + cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo); + if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount)) + vn_encode_uint32_t(enc, pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); + for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) + vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pInfo */ + cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirementCount) + cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); + for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++) + cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT); + + /* skip device */ + /* skip pInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pSparseMemoryRequirementCount); + } else { + pSparseMemoryRequirementCount = NULL; + } + if (vn_peek_array_size(dec)) { + const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)); + for (uint32_t i = 0; i < iter_count; i++) + vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]); + } else { + vn_decode_array_size_unchecked(dec); + pSparseMemoryRequirements = NULL; + } +} + static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; @@ -2090,6 +2474,48 @@ static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_insta } } +static inline void vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkGetDeviceImageMemoryRequirements(enc, cmd_flags, device, pInfo, pMemoryRequirements); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkGetDeviceImageSparseMemoryRequirements(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit) { uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; @@ -2291,6 +2717,44 @@ static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instan vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); } +static inline void vn_call_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkGetDeviceImageMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit); +} + +static inline void vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); +} + static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { VN_TRACE_FUNC(); diff --git a/src/virtio/venus-protocol/vn_protocol_driver_info.h b/src/virtio/venus-protocol/vn_protocol_driver_info.h index 3ba00d8cc94..764f1a98d2e 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_info.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_info.h @@ -10,6 +10,13 @@ #include "vn_protocol_driver_defines.h" +struct vn_info_extension { + uint32_t index; + + const char *name; + uint32_t spec_version; +}; + static inline uint32_t vn_info_wire_format_version(void) { @@ -19,137 +26,100 @@ vn_info_wire_format_version(void) static inline uint32_t vn_info_vk_xml_version(void) { - return VK_MAKE_API_VERSION(0, 1, 2, 182); + return VK_MAKE_API_VERSION(0, 1, 3, 204); } static inline int -vn_info_extension_compare(const void *a, const void *b) +vn_info_extension_compare(const void *name, const void *ext) { - return strcmp(a, *(const char **)b); + return strcmp(name, ((const struct vn_info_extension *)ext)->name); } -static inline uint32_t -vn_info_extension_spec_version(const char *name) +static inline const struct vn_info_extension * +vn_info_extension_get(const char *name) { - static uint32_t ext_count = 54; - static const char *ext_names[54] = { - "VK_EXT_command_serialization", - "VK_EXT_descriptor_indexing", - "VK_EXT_external_memory_dma_buf", - "VK_EXT_host_query_reset", - "VK_EXT_image_drm_format_modifier", - "VK_EXT_queue_family_foreign", - "VK_EXT_sampler_filter_minmax", - "VK_EXT_scalar_block_layout", - "VK_EXT_separate_stencil_usage", - "VK_EXT_shader_viewport_index_layer", - "VK_EXT_transform_feedback", - "VK_KHR_16bit_storage", - "VK_KHR_8bit_storage", - "VK_KHR_bind_memory2", - "VK_KHR_buffer_device_address", - "VK_KHR_create_renderpass2", - "VK_KHR_dedicated_allocation", - "VK_KHR_depth_stencil_resolve", - "VK_KHR_descriptor_update_template", - "VK_KHR_device_group", - "VK_KHR_device_group_creation", - "VK_KHR_draw_indirect_count", - "VK_KHR_driver_properties", - "VK_KHR_external_fence", - "VK_KHR_external_fence_capabilities", - "VK_KHR_external_memory", - "VK_KHR_external_memory_capabilities", - "VK_KHR_external_memory_fd", - "VK_KHR_external_semaphore", - "VK_KHR_external_semaphore_capabilities", - "VK_KHR_get_memory_requirements2", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_image_format_list", - "VK_KHR_imageless_framebuffer", - "VK_KHR_maintenance1", - "VK_KHR_maintenance2", - "VK_KHR_maintenance3", - "VK_KHR_multiview", - "VK_KHR_relaxed_block_layout", - "VK_KHR_sampler_mirror_clamp_to_edge", - "VK_KHR_sampler_ycbcr_conversion", - "VK_KHR_separate_depth_stencil_layouts", - "VK_KHR_shader_atomic_int64", - "VK_KHR_shader_draw_parameters", - "VK_KHR_shader_float16_int8", - "VK_KHR_shader_float_controls", - "VK_KHR_shader_subgroup_extended_types", - "VK_KHR_spirv_1_4", - "VK_KHR_storage_buffer_storage_class", - "VK_KHR_timeline_semaphore", - "VK_KHR_uniform_buffer_standard_layout", - "VK_KHR_variable_pointers", - "VK_KHR_vulkan_memory_model", - "VK_MESA_venus_protocol", - }; - static const uint32_t ext_versions[54] = { - 0, - 2, - 1, - 1, - 1, - 1, - 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 3, - 1, - 1, - 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 2, - 1, - 1, - 2, - 1, - 1, - 1, - 1, - 3, - 14, - 1, - 1, - 1, - 1, - 4, - 1, - 1, - 1, - 2, - 1, - 1, - 3, - 100000, - }; - const char **found; + static const struct vn_info_extension vn_info_extensions[77] = { + { 0, "VK_EXT_4444_formats", 1 }, + { 1, "VK_EXT_command_serialization", 0 }, + { 2, "VK_EXT_descriptor_indexing", 2 }, + { 3, "VK_EXT_extended_dynamic_state", 1 }, + { 4, "VK_EXT_extended_dynamic_state2", 1 }, + { 5, "VK_EXT_external_memory_dma_buf", 1 }, + { 6, "VK_EXT_host_query_reset", 1 }, + { 7, "VK_EXT_image_drm_format_modifier", 2 }, + { 8, "VK_EXT_image_robustness", 1 }, + { 9, "VK_EXT_inline_uniform_block", 1 }, + { 10, "VK_EXT_pipeline_creation_cache_control", 3 }, + { 11, "VK_EXT_pipeline_creation_feedback", 1 }, + { 12, "VK_EXT_private_data", 1 }, + { 13, "VK_EXT_queue_family_foreign", 1 }, + { 14, "VK_EXT_sampler_filter_minmax", 2 }, + { 15, "VK_EXT_scalar_block_layout", 1 }, + { 16, "VK_EXT_separate_stencil_usage", 1 }, + { 17, "VK_EXT_shader_demote_to_helper_invocation", 1 }, + { 18, "VK_EXT_shader_viewport_index_layer", 1 }, + { 19, "VK_EXT_subgroup_size_control", 2 }, + { 20, "VK_EXT_texel_buffer_alignment", 1 }, + { 21, "VK_EXT_texture_compression_astc_hdr", 1 }, + { 22, "VK_EXT_tooling_info", 1 }, + { 23, "VK_EXT_transform_feedback", 1 }, + { 24, "VK_EXT_ycbcr_2plane_444_formats", 1 }, + { 25, "VK_KHR_16bit_storage", 1 }, + { 26, "VK_KHR_8bit_storage", 1 }, + { 27, "VK_KHR_bind_memory2", 1 }, + { 28, "VK_KHR_buffer_device_address", 1 }, + { 29, "VK_KHR_copy_commands2", 1 }, + { 30, "VK_KHR_create_renderpass2", 1 }, + { 31, "VK_KHR_dedicated_allocation", 3 }, + { 32, "VK_KHR_depth_stencil_resolve", 1 }, + { 33, "VK_KHR_descriptor_update_template", 1 }, + { 34, "VK_KHR_device_group", 4 }, + { 35, "VK_KHR_device_group_creation", 1 }, + { 36, "VK_KHR_draw_indirect_count", 1 }, + { 37, "VK_KHR_driver_properties", 1 }, + { 38, "VK_KHR_dynamic_rendering", 1 }, + { 39, "VK_KHR_external_fence", 1 }, + { 40, "VK_KHR_external_fence_capabilities", 1 }, + { 41, "VK_KHR_external_memory", 1 }, + { 42, "VK_KHR_external_memory_capabilities", 1 }, + { 43, "VK_KHR_external_memory_fd", 1 }, + { 44, "VK_KHR_external_semaphore", 1 }, + { 45, "VK_KHR_external_semaphore_capabilities", 1 }, + { 46, "VK_KHR_format_feature_flags2", 1 }, + { 47, "VK_KHR_get_memory_requirements2", 1 }, + { 48, "VK_KHR_get_physical_device_properties2", 2 }, + { 49, "VK_KHR_image_format_list", 1 }, + { 50, "VK_KHR_imageless_framebuffer", 1 }, + { 51, "VK_KHR_maintenance1", 2 }, + { 52, "VK_KHR_maintenance2", 1 }, + { 53, "VK_KHR_maintenance3", 1 }, + { 54, "VK_KHR_maintenance4", 2 }, + { 55, "VK_KHR_multiview", 1 }, + { 56, "VK_KHR_relaxed_block_layout", 1 }, + { 57, "VK_KHR_sampler_mirror_clamp_to_edge", 3 }, + { 58, "VK_KHR_sampler_ycbcr_conversion", 14 }, + { 59, "VK_KHR_separate_depth_stencil_layouts", 1 }, + { 60, "VK_KHR_shader_atomic_int64", 1 }, + { 61, "VK_KHR_shader_draw_parameters", 1 }, + { 62, "VK_KHR_shader_float16_int8", 1 }, + { 63, "VK_KHR_shader_float_controls", 4 }, + { 64, "VK_KHR_shader_integer_dot_product", 1 }, + { 65, "VK_KHR_shader_non_semantic_info", 1 }, + { 66, "VK_KHR_shader_subgroup_extended_types", 1 }, + { 67, "VK_KHR_shader_terminate_invocation", 1 }, + { 68, "VK_KHR_spirv_1_4", 1 }, + { 69, "VK_KHR_storage_buffer_storage_class", 1 }, + { 70, "VK_KHR_synchronization2", 1 }, + { 71, "VK_KHR_timeline_semaphore", 2 }, + { 72, "VK_KHR_uniform_buffer_standard_layout", 1 }, + { 73, "VK_KHR_variable_pointers", 1 }, + { 74, "VK_KHR_vulkan_memory_model", 3 }, + { 75, "VK_KHR_zero_initialize_workgroup_memory", 1 }, + { 76, "VK_MESA_venus_protocol", 100000 }, + }; - found = bsearch(name, ext_names, ext_count, sizeof(ext_names[0]), - vn_info_extension_compare); - - return found ? ext_versions[found - ext_names] : 0; + return bsearch(name, vn_info_extensions, 77, + sizeof(*vn_info_extensions), vn_info_extension_compare); } #endif /* VN_PROTOCOL_DRIVER_INFO_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h b/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h index 9d13d465a5d..3e6115b025f 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_pipeline.h @@ -75,12 +75,82 @@ vn_encode_VkSpecializationInfo(struct vn_cs_encoder *enc, const VkSpecialization } } +/* struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->requiredSubgroupSize); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->requiredSubgroupSize); +} + +static inline void +vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO }); + vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, val); +} + /* struct VkPipelineShaderStageCreateInfo chain */ static inline size_t vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self((const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -120,7 +190,23 @@ vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo static inline void vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } @@ -1070,12 +1156,196 @@ vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPi vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val); } +/* struct VkPipelineCreationFeedback */ + +static inline size_t +vn_sizeof_VkPipelineCreationFeedback(const VkPipelineCreationFeedback *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint64_t(&val->duration); + return size; +} + +static inline void +vn_encode_VkPipelineCreationFeedback(struct vn_cs_encoder *enc, const VkPipelineCreationFeedback *val) +{ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint64_t(enc, &val->duration); +} + +/* struct VkPipelineCreationFeedbackCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(const VkPipelineCreationFeedbackCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_simple_pointer(val->pPipelineCreationFeedback); + if (val->pPipelineCreationFeedback) + size += vn_sizeof_VkPipelineCreationFeedback(val->pPipelineCreationFeedback); + size += vn_sizeof_uint32_t(&val->pipelineStageCreationFeedbackCount); + if (val->pPipelineStageCreationFeedbacks) { + size += vn_sizeof_array_size(val->pipelineStageCreationFeedbackCount); + for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++) + size += vn_sizeof_VkPipelineCreationFeedback(&val->pPipelineStageCreationFeedbacks[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineCreationFeedbackCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + if (vn_encode_simple_pointer(enc, val->pPipelineCreationFeedback)) + vn_encode_VkPipelineCreationFeedback(enc, val->pPipelineCreationFeedback); + vn_encode_uint32_t(enc, &val->pipelineStageCreationFeedbackCount); + if (val->pPipelineStageCreationFeedbacks) { + vn_encode_array_size(enc, val->pipelineStageCreationFeedbackCount); + for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++) + vn_encode_VkPipelineCreationFeedback(enc, &val->pPipelineStageCreationFeedbacks[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPipelineCreationFeedbackCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO }); + vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, val); +} + +/* struct VkPipelineRenderingCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineRenderingCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineRenderingCreateInfo_self(const VkPipelineRenderingCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->viewMask); + size += vn_sizeof_uint32_t(&val->colorAttachmentCount); + if (val->pColorAttachmentFormats) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + size += vn_sizeof_VkFormat_array(val->pColorAttachmentFormats, val->colorAttachmentCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_VkFormat(&val->depthAttachmentFormat); + size += vn_sizeof_VkFormat(&val->stencilAttachmentFormat); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineRenderingCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineRenderingCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineRenderingCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineRenderingCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->viewMask); + vn_encode_uint32_t(enc, &val->colorAttachmentCount); + if (val->pColorAttachmentFormats) { + vn_encode_array_size(enc, val->colorAttachmentCount); + vn_encode_VkFormat_array(enc, val->pColorAttachmentFormats, val->colorAttachmentCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFormat(enc, &val->depthAttachmentFormat); + vn_encode_VkFormat(enc, &val->stencilAttachmentFormat); +} + +static inline void +vn_encode_VkPipelineRenderingCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO }); + vn_encode_VkPipelineRenderingCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineRenderingCreateInfo_self(enc, val); +} + /* struct VkGraphicsPipelineCreateInfo chain */ static inline size_t vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPipelineRenderingCreateInfo_self((const VkPipelineRenderingCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -1143,7 +1413,29 @@ vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val) static inline void vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPipelineRenderingCreateInfo_self(enc, (const VkPipelineRenderingCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } @@ -1199,7 +1491,24 @@ vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphi static inline size_t vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkComputePipelineCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -1231,7 +1540,23 @@ vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val) static inline void vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkComputePipelineCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } diff --git a/src/virtio/venus-protocol/vn_protocol_driver_private_data_slot.h b/src/virtio/venus-protocol/vn_protocol_driver_private_data_slot.h new file mode 100644 index 00000000000..2eb3d7d5690 --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_private_data_slot.h @@ -0,0 +1,481 @@ +/* This file is generated by venus-protocol. See vn_protocol_driver.h. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_PRIVATE_DATA_SLOT_H +#define VN_PROTOCOL_DRIVER_PRIVATE_DATA_SLOT_H + +#include "vn_instance.h" +#include "vn_protocol_driver_structs.h" + +/* struct VkPrivateDataSlotCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPrivateDataSlotCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPrivateDataSlotCreateInfo_self(const VkPrivateDataSlotCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline size_t +vn_sizeof_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPrivateDataSlotCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPrivateDataSlotCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPrivateDataSlotCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPrivateDataSlotCreateInfo_self(struct vn_cs_encoder *enc, const VkPrivateDataSlotCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); +} + +static inline void +vn_encode_VkPrivateDataSlotCreateInfo(struct vn_cs_encoder *enc, const VkPrivateDataSlotCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO }); + vn_encode_VkPrivateDataSlotCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPrivateDataSlotCreateInfo_self(enc, val); +} + +static inline size_t vn_sizeof_vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkPrivateDataSlotCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pPrivateDataSlot); + if (pPrivateDataSlot) + cmd_size += vn_sizeof_VkPrivateDataSlot(pPrivateDataSlot); + + return cmd_size; +} + +static inline void vn_encode_vkCreatePrivateDataSlot(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkPrivateDataSlotCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pPrivateDataSlot)) + vn_encode_VkPrivateDataSlot(enc, pPrivateDataSlot); +} + +static inline size_t vn_sizeof_vkCreatePrivateDataSlot_reply(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pPrivateDataSlot); + if (pPrivateDataSlot) + cmd_size += vn_sizeof_VkPrivateDataSlot(pPrivateDataSlot); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreatePrivateDataSlot_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPrivateDataSlot(dec, pPrivateDataSlot); + } else { + pPrivateDataSlot = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPrivateDataSlot(&privateDataSlot); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyPrivateDataSlot(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPrivateDataSlot(enc, &privateDataSlot); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyPrivateDataSlot_reply(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip privateDataSlot */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyPrivateDataSlot_reply(struct vn_cs_decoder *dec, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT); + + /* skip device */ + /* skip privateDataSlot */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetPrivateData_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkObjectType(&objectType); + cmd_size += vn_sizeof_uint64_t(&objectHandle); + cmd_size += vn_sizeof_VkPrivateDataSlot(&privateDataSlot); + cmd_size += vn_sizeof_uint64_t(&data); + + return cmd_size; +} + +static inline void vn_encode_vkSetPrivateData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetPrivateData_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkObjectType(enc, &objectType); + vn_encode_uint64_t(enc, &objectHandle); + vn_encode_VkPrivateDataSlot(enc, &privateDataSlot); + vn_encode_uint64_t(enc, &data); +} + +static inline size_t vn_sizeof_vkSetPrivateData_reply(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetPrivateData_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip objectType */ + /* skip objectHandle */ + /* skip privateDataSlot */ + /* skip data */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkSetPrivateData_reply(struct vn_cs_decoder *dec, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkSetPrivateData_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip objectType */ + /* skip objectHandle */ + /* skip privateDataSlot */ + /* skip data */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPrivateData_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkObjectType(&objectType); + cmd_size += vn_sizeof_uint64_t(&objectHandle); + cmd_size += vn_sizeof_VkPrivateDataSlot(&privateDataSlot); + cmd_size += vn_sizeof_simple_pointer(pData); /* out */ + + return cmd_size; +} + +static inline void vn_encode_vkGetPrivateData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPrivateData_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkObjectType(enc, &objectType); + vn_encode_uint64_t(enc, &objectHandle); + vn_encode_VkPrivateDataSlot(enc, &privateDataSlot); + vn_encode_simple_pointer(enc, pData); /* out */ +} + +static inline size_t vn_sizeof_vkGetPrivateData_reply(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPrivateData_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip objectType */ + /* skip objectHandle */ + /* skip privateDataSlot */ + cmd_size += vn_sizeof_simple_pointer(pData); + if (pData) + cmd_size += vn_sizeof_uint64_t(pData); + + return cmd_size; +} + +static inline void vn_decode_vkGetPrivateData_reply(struct vn_cs_decoder *dec, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPrivateData_EXT); + + /* skip device */ + /* skip objectType */ + /* skip objectHandle */ + /* skip privateDataSlot */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint64_t(dec, pData); + } else { + pData = NULL; + } +} + +static inline void vn_submit_vkCreatePrivateDataSlot(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePrivateDataSlot_reply(device, pCreateInfo, pAllocator, pPrivateDataSlot) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkCreatePrivateDataSlot(enc, cmd_flags, device, pCreateInfo, pAllocator, pPrivateDataSlot); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkDestroyPrivateDataSlot(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPrivateDataSlot_reply(device, privateDataSlot, pAllocator) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkDestroyPrivateDataSlot(enc, cmd_flags, device, privateDataSlot, pAllocator); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkSetPrivateData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetPrivateData_reply(device, objectType, objectHandle, privateDataSlot, data) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkSetPrivateData(enc, cmd_flags, device, objectType, objectHandle, privateDataSlot, data); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline void vn_submit_vkGetPrivateData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPrivateData_reply(device, objectType, objectHandle, privateDataSlot, pData) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkGetPrivateData(enc, cmd_flags, device, objectType, objectHandle, privateDataSlot, pData); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + +static inline VkResult vn_call_vkCreatePrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkCreatePrivateDataSlot(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPrivateDataSlot, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + const VkResult ret = vn_decode_vkCreatePrivateDataSlot_reply(dec, device, pCreateInfo, pAllocator, pPrivateDataSlot); + vn_instance_free_command_reply(vn_instance, &submit); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreatePrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreatePrivateDataSlot(vn_instance, 0, device, pCreateInfo, pAllocator, pPrivateDataSlot, &submit); +} + +static inline void vn_call_vkDestroyPrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPrivateDataSlot(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, privateDataSlot, pAllocator, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkDestroyPrivateDataSlot_reply(dec, device, privateDataSlot, pAllocator); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkDestroyPrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPrivateDataSlot(vn_instance, 0, device, privateDataSlot, pAllocator, &submit); +} + +static inline VkResult vn_call_vkSetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkSetPrivateData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, objectType, objectHandle, privateDataSlot, data, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + const VkResult ret = vn_decode_vkSetPrivateData_reply(dec, device, objectType, objectHandle, privateDataSlot, data); + vn_instance_free_command_reply(vn_instance, &submit); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkSetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSetPrivateData(vn_instance, 0, device, objectType, objectHandle, privateDataSlot, data, &submit); +} + +static inline void vn_call_vkGetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkGetPrivateData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, objectType, objectHandle, privateDataSlot, pData, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + vn_decode_vkGetPrivateData_reply(dec, device, objectType, objectHandle, privateDataSlot, pData); + vn_instance_free_command_reply(vn_instance, &submit); + } +} + +static inline void vn_async_vkGetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPrivateData(vn_instance, 0, device, objectType, objectHandle, privateDataSlot, pData, &submit); +} + +#endif /* VN_PROTOCOL_DRIVER_PRIVATE_DATA_SLOT_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_queue.h b/src/virtio/venus-protocol/vn_protocol_driver_queue.h index 99b6f1c6085..122704b3d7b 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_queue.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_queue.h @@ -783,6 +783,221 @@ vn_encode_VkBindSparseInfo(struct vn_cs_encoder *enc, const VkBindSparseInfo *va vn_encode_VkBindSparseInfo_self(enc, val); } +/* struct VkSemaphoreSubmitInfo chain */ + +static inline size_t +vn_sizeof_VkSemaphoreSubmitInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSemaphoreSubmitInfo_self(const VkSemaphoreSubmitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSemaphore(&val->semaphore); + size += vn_sizeof_uint64_t(&val->value); + size += vn_sizeof_VkFlags64(&val->stageMask); + size += vn_sizeof_uint32_t(&val->deviceIndex); + return size; +} + +static inline size_t +vn_sizeof_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSemaphoreSubmitInfo_pnext(val->pNext); + size += vn_sizeof_VkSemaphoreSubmitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSubmitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSemaphore(enc, &val->semaphore); + vn_encode_uint64_t(enc, &val->value); + vn_encode_VkFlags64(enc, &val->stageMask); + vn_encode_uint32_t(enc, &val->deviceIndex); +} + +static inline void +vn_encode_VkSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkSemaphoreSubmitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO }); + vn_encode_VkSemaphoreSubmitInfo_pnext(enc, val->pNext); + vn_encode_VkSemaphoreSubmitInfo_self(enc, val); +} + +/* struct VkCommandBufferSubmitInfo chain */ + +static inline size_t +vn_sizeof_VkCommandBufferSubmitInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCommandBufferSubmitInfo_self(const VkCommandBufferSubmitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkCommandBuffer(&val->commandBuffer); + size += vn_sizeof_uint32_t(&val->deviceMask); + return size; +} + +static inline size_t +vn_sizeof_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCommandBufferSubmitInfo_pnext(val->pNext); + size += vn_sizeof_VkCommandBufferSubmitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkCommandBufferSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCommandBufferSubmitInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferSubmitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkCommandBuffer(enc, &val->commandBuffer); + vn_encode_uint32_t(enc, &val->deviceMask); +} + +static inline void +vn_encode_VkCommandBufferSubmitInfo(struct vn_cs_encoder *enc, const VkCommandBufferSubmitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO }); + vn_encode_VkCommandBufferSubmitInfo_pnext(enc, val->pNext); + vn_encode_VkCommandBufferSubmitInfo_self(enc, val); +} + +/* struct VkSubmitInfo2 chain */ + +static inline size_t +vn_sizeof_VkSubmitInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubmitInfo2_self(const VkSubmitInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->waitSemaphoreInfoCount); + if (val->pWaitSemaphoreInfos) { + size += vn_sizeof_array_size(val->waitSemaphoreInfoCount); + for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++) + size += vn_sizeof_VkSemaphoreSubmitInfo(&val->pWaitSemaphoreInfos[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->commandBufferInfoCount); + if (val->pCommandBufferInfos) { + size += vn_sizeof_array_size(val->commandBufferInfoCount); + for (uint32_t i = 0; i < val->commandBufferInfoCount; i++) + size += vn_sizeof_VkCommandBufferSubmitInfo(&val->pCommandBufferInfos[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->signalSemaphoreInfoCount); + if (val->pSignalSemaphoreInfos) { + size += vn_sizeof_array_size(val->signalSemaphoreInfoCount); + for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++) + size += vn_sizeof_VkSemaphoreSubmitInfo(&val->pSignalSemaphoreInfos[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkSubmitInfo2(const VkSubmitInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubmitInfo2_pnext(val->pNext); + size += vn_sizeof_VkSubmitInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkSubmitInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubmitInfo2_self(struct vn_cs_encoder *enc, const VkSubmitInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->waitSemaphoreInfoCount); + if (val->pWaitSemaphoreInfos) { + vn_encode_array_size(enc, val->waitSemaphoreInfoCount); + for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++) + vn_encode_VkSemaphoreSubmitInfo(enc, &val->pWaitSemaphoreInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->commandBufferInfoCount); + if (val->pCommandBufferInfos) { + vn_encode_array_size(enc, val->commandBufferInfoCount); + for (uint32_t i = 0; i < val->commandBufferInfoCount; i++) + vn_encode_VkCommandBufferSubmitInfo(enc, &val->pCommandBufferInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->signalSemaphoreInfoCount); + if (val->pSignalSemaphoreInfos) { + vn_encode_array_size(enc, val->signalSemaphoreInfoCount); + for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++) + vn_encode_VkSemaphoreSubmitInfo(enc, &val->pSignalSemaphoreInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkSubmitInfo2(struct vn_cs_encoder *enc, const VkSubmitInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO_2 }); + vn_encode_VkSubmitInfo2_pnext(enc, val->pNext); + vn_encode_VkSubmitInfo2_self(enc, val); +} + static inline size_t vn_sizeof_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT; @@ -969,6 +1184,76 @@ static inline VkResult vn_decode_vkQueueBindSparse_reply(struct vn_cs_decoder *d return ret; } +static inline size_t vn_sizeof_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkQueue(&queue); + cmd_size += vn_sizeof_uint32_t(&submitCount); + if (pSubmits) { + cmd_size += vn_sizeof_array_size(submitCount); + for (uint32_t i = 0; i < submitCount; i++) + cmd_size += vn_sizeof_VkSubmitInfo2(&pSubmits[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkFence(&fence); + + return cmd_size; +} + +static inline void vn_encode_vkQueueSubmit2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkQueue(enc, &queue); + vn_encode_uint32_t(enc, &submitCount); + if (pSubmits) { + vn_encode_array_size(enc, submitCount); + for (uint32_t i = 0; i < submitCount; i++) + vn_encode_VkSubmitInfo2(enc, &pSubmits[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFence(enc, &fence); +} + +static inline size_t vn_sizeof_vkQueueSubmit2_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip queue */ + /* skip submitCount */ + /* skip pSubmits */ + /* skip fence */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkQueueSubmit2_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit2_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip queue */ + /* skip submitCount */ + /* skip pSubmits */ + /* skip fence */ + + return ret; +} + static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, struct vn_instance_submit_command *submit) { uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; @@ -1032,6 +1317,27 @@ static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance, } } +static inline void vn_submit_vkQueueSubmit2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkQueueSubmit2(queue, submitCount, pSubmits, fence); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit2_reply(queue, submitCount, pSubmits, fence) : 0; + + struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size); + if (cmd_size) { + vn_encode_vkQueueSubmit2(enc, cmd_flags, queue, submitCount, pSubmits, fence); + vn_instance_submit_command(vn_instance, submit); + if (cmd_data != local_cmd_data) + free(cmd_data); + } +} + static inline VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { VN_TRACE_FUNC(); @@ -1098,4 +1404,26 @@ static inline void vn_async_vkQueueBindSparse(struct vn_instance *vn_instance, V vn_submit_vkQueueBindSparse(vn_instance, 0, queue, bindInfoCount, pBindInfo, fence, &submit); } +static inline VkResult vn_call_vkQueueSubmit2(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + VN_TRACE_FUNC(); + + struct vn_instance_submit_command submit; + vn_submit_vkQueueSubmit2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit); + struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit); + if (dec) { + const VkResult ret = vn_decode_vkQueueSubmit2_reply(dec, queue, submitCount, pSubmits, fence); + vn_instance_free_command_reply(vn_instance, &submit); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkQueueSubmit2(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueSubmit2(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit); +} + #endif /* VN_PROTOCOL_DRIVER_QUEUE_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h b/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h index 64a4e3c42b2..59ff095526c 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_render_pass.h @@ -1018,7 +1018,24 @@ vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescri static inline size_t vn_sizeof_VkSubpassDependency2_pnext(const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSubpassDependency2_pnext(pnext->pNext); + size += vn_sizeof_VkMemoryBarrier2_self((const VkMemoryBarrier2 *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + return vn_sizeof_simple_pointer(NULL); } @@ -1053,7 +1070,23 @@ vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val) static inline void vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val) { - /* no known/supported struct */ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSubpassDependency2_pnext(enc, pnext->pNext); + vn_encode_VkMemoryBarrier2_self(enc, (const VkMemoryBarrier2 *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + vn_encode_simple_pointer(enc, NULL); } diff --git a/src/virtio/venus-protocol/vn_protocol_driver_structs.h b/src/virtio/venus-protocol/vn_protocol_driver_structs.h index 183fa735af0..9741fe0ce5b 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_structs.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_structs.h @@ -394,6 +394,40 @@ vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFo vn_encode_VkImageFormatListCreateInfo_self(enc, val); } +static inline void +vn_decode_VkImageFormatListCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkImageFormatListCreateInfo_self(struct vn_cs_decoder *dec, VkImageFormatListCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->viewFormatCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->viewFormatCount); + vn_decode_VkFormat_array(dec, (VkFormat *)val->pViewFormats, array_size); + } else { + vn_decode_array_size_unchecked(dec); + val->pViewFormats = NULL; + } +} + +static inline void +vn_decode_VkImageFormatListCreateInfo(struct vn_cs_decoder *dec, VkImageFormatListCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkImageFormatListCreateInfo_pnext(dec, val->pNext); + vn_decode_VkImageFormatListCreateInfo_self(dec, val); +} + /* struct VkImageStencilUsageCreateInfo chain */ static inline size_t @@ -447,6 +481,33 @@ vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImage vn_encode_VkImageStencilUsageCreateInfo_self(enc, val); } +static inline void +vn_decode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkImageStencilUsageCreateInfo_self(struct vn_cs_decoder *dec, VkImageStencilUsageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->stencilUsage); +} + +static inline void +vn_decode_VkImageStencilUsageCreateInfo(struct vn_cs_decoder *dec, VkImageStencilUsageCreateInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO); + + assert(val->sType == stype); + vn_decode_VkImageStencilUsageCreateInfo_pnext(dec, val->pNext); + vn_decode_VkImageStencilUsageCreateInfo_self(dec, val); +} + /* struct VkComponentMapping */ static inline size_t @@ -1024,4 +1085,63 @@ vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkMemor vn_encode_VkMemoryRequirements2_self_partial(enc, val); } +/* struct VkMemoryBarrier2 chain */ + +static inline size_t +vn_sizeof_VkMemoryBarrier2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryBarrier2_self(const VkMemoryBarrier2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags64(&val->srcStageMask); + size += vn_sizeof_VkFlags64(&val->srcAccessMask); + size += vn_sizeof_VkFlags64(&val->dstStageMask); + size += vn_sizeof_VkFlags64(&val->dstAccessMask); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryBarrier2(const VkMemoryBarrier2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryBarrier2_pnext(val->pNext); + size += vn_sizeof_VkMemoryBarrier2_self(val); + + return size; +} + +static inline void +vn_encode_VkMemoryBarrier2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryBarrier2_self(struct vn_cs_encoder *enc, const VkMemoryBarrier2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags64(enc, &val->srcStageMask); + vn_encode_VkFlags64(enc, &val->srcAccessMask); + vn_encode_VkFlags64(enc, &val->dstStageMask); + vn_encode_VkFlags64(enc, &val->dstAccessMask); +} + +static inline void +vn_encode_VkMemoryBarrier2(struct vn_cs_encoder *enc, const VkMemoryBarrier2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_BARRIER_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 }); + vn_encode_VkMemoryBarrier2_pnext(enc, val->pNext); + vn_encode_VkMemoryBarrier2_self(enc, val); +} + #endif /* VN_PROTOCOL_DRIVER_STRUCTS_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_types.h b/src/virtio/venus-protocol/vn_protocol_driver_types.h index b545bdc8a8d..48f04d349be 100644 --- a/src/virtio/venus-protocol/vn_protocol_driver_types.h +++ b/src/virtio/venus-protocol/vn_protocol_driver_types.h @@ -534,6 +534,26 @@ vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count) vn_decode_uint32_t_array(dec, val, count); } +/* typedef uint64_t VkFlags64 */ + +static inline size_t +vn_sizeof_VkFlags64(const VkFlags64 *val) +{ + return vn_sizeof_uint64_t(val); +} + +static inline void +vn_encode_VkFlags64(struct vn_cs_encoder *enc, const VkFlags64 *val) +{ + vn_encode_uint64_t(enc, val); +} + +static inline void +vn_decode_VkFlags64(struct vn_cs_decoder *dec, VkFlags64 *val) +{ + vn_decode_uint64_t(dec, val); +} + /* typedef uint64_t VkDeviceSize */ static inline size_t @@ -694,6 +714,48 @@ vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCac vn_decode_int32_t(dec, (int32_t *)val); } +/* enum VkPipelineDepthStencilStateCreateFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineDepthStencilStateCreateFlagBits(const VkPipelineDepthStencilStateCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineColorBlendStateCreateFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineColorBlendStateCreateFlagBits(const VkPipelineColorBlendStateCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + /* enum VkPipelineShaderStageCreateFlagBits */ static inline size_t @@ -1345,6 +1407,24 @@ vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits vn_decode_int32_t(dec, (int32_t *)val); } +static inline size_t +vn_sizeof_VkSampleCountFlagBits_array(const VkSampleCountFlagBits *val, uint32_t count) +{ + return vn_sizeof_int32_t_array((const int32_t *)val, count); +} + +static inline void +vn_encode_VkSampleCountFlagBits_array(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val, uint32_t count) +{ + vn_encode_int32_t_array(enc, (const int32_t *)val, count); +} + +static inline void +vn_decode_VkSampleCountFlagBits_array(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val, uint32_t count) +{ + vn_decode_int32_t_array(dec, (int32_t *)val, count); +} + /* enum VkAttachmentDescriptionFlagBits */ static inline size_t @@ -1471,6 +1551,27 @@ vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeature vn_decode_int32_t(dec, (int32_t *)val); } +/* enum VkPipelineCreationFeedbackFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineCreationFeedbackFlagBits(const VkPipelineCreationFeedbackFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + /* enum VkSemaphoreWaitFlagBits */ static inline size_t @@ -1492,6 +1593,90 @@ vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlag vn_decode_int32_t(dec, (int32_t *)val); } +/* typedef VkFlags64 VkAccessFlagBits2 */ + +static inline size_t +vn_sizeof_VkAccessFlagBits2(const VkAccessFlagBits2 *val) +{ + assert(sizeof(*val) == sizeof(uint64_t)); + return vn_sizeof_uint64_t((const uint64_t *)val); +} + +static inline void +vn_encode_VkAccessFlagBits2(struct vn_cs_encoder *enc, const VkAccessFlagBits2 *val) +{ + vn_encode_uint64_t(enc, (const uint64_t *)val); +} + +static inline void +vn_decode_VkAccessFlagBits2(struct vn_cs_decoder *dec, VkAccessFlagBits2 *val) +{ + vn_decode_uint64_t(dec, (uint64_t *)val); +} + +/* typedef VkFlags64 VkPipelineStageFlagBits2 */ + +static inline size_t +vn_sizeof_VkPipelineStageFlagBits2(const VkPipelineStageFlagBits2 *val) +{ + assert(sizeof(*val) == sizeof(uint64_t)); + return vn_sizeof_uint64_t((const uint64_t *)val); +} + +static inline void +vn_encode_VkPipelineStageFlagBits2(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits2 *val) +{ + vn_encode_uint64_t(enc, (const uint64_t *)val); +} + +static inline void +vn_decode_VkPipelineStageFlagBits2(struct vn_cs_decoder *dec, VkPipelineStageFlagBits2 *val) +{ + vn_decode_uint64_t(dec, (uint64_t *)val); +} + +/* typedef VkFlags64 VkFormatFeatureFlagBits2 */ + +static inline size_t +vn_sizeof_VkFormatFeatureFlagBits2(const VkFormatFeatureFlagBits2 *val) +{ + assert(sizeof(*val) == sizeof(uint64_t)); + return vn_sizeof_uint64_t((const uint64_t *)val); +} + +static inline void +vn_encode_VkFormatFeatureFlagBits2(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits2 *val) +{ + vn_encode_uint64_t(enc, (const uint64_t *)val); +} + +static inline void +vn_decode_VkFormatFeatureFlagBits2(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits2 *val) +{ + vn_decode_uint64_t(dec, (uint64_t *)val); +} + +/* enum VkRenderingFlagBits */ + +static inline size_t +vn_sizeof_VkRenderingFlagBits(const VkRenderingFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkRenderingFlagBits(struct vn_cs_encoder *enc, const VkRenderingFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkRenderingFlagBits(struct vn_cs_decoder *dec, VkRenderingFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + /* enum VkPeerMemoryFeatureFlagBits */ static inline size_t @@ -1744,6 +1929,48 @@ vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits vn_decode_int32_t(dec, (int32_t *)val); } +/* enum VkToolPurposeFlagBits */ + +static inline size_t +vn_sizeof_VkToolPurposeFlagBits(const VkToolPurposeFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkToolPurposeFlagBits(struct vn_cs_encoder *enc, const VkToolPurposeFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkToolPurposeFlagBits(struct vn_cs_decoder *dec, VkToolPurposeFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSubmitFlagBits */ + +static inline size_t +vn_sizeof_VkSubmitFlagBits(const VkSubmitFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSubmitFlagBits(struct vn_cs_encoder *enc, const VkSubmitFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSubmitFlagBits(struct vn_cs_decoder *dec, VkSubmitFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + /* enum VkAttachmentLoadOp */ static inline size_t diff --git a/src/virtio/vulkan/vn_instance.c b/src/virtio/vulkan/vn_instance.c index 57d250f5582..1093d1e1d27 100644 --- a/src/virtio/vulkan/vn_instance.c +++ b/src/virtio/vulkan/vn_instance.c @@ -267,17 +267,19 @@ vn_instance_init_renderer(struct vn_instance *instance) return VK_ERROR_INITIALIZATION_FAILED; } - version = vn_info_extension_spec_version("VK_EXT_command_serialization"); + const struct vn_info_extension *ext = + vn_info_extension_get("VK_EXT_command_serialization"); if (instance->renderer_info.vk_ext_command_serialization_spec_version > - version) { + ext->spec_version) { instance->renderer_info.vk_ext_command_serialization_spec_version = - version; + ext->spec_version; } - version = vn_info_extension_spec_version("VK_MESA_venus_protocol"); + ext = vn_info_extension_get("VK_MESA_venus_protocol"); if (instance->renderer_info.vk_mesa_venus_protocol_spec_version > - version) { - instance->renderer_info.vk_mesa_venus_protocol_spec_version = version; + ext->spec_version) { + instance->renderer_info.vk_mesa_venus_protocol_spec_version = + ext->spec_version; } if (VN_DEBUG(INIT)) { diff --git a/src/virtio/vulkan/vn_physical_device.c b/src/virtio/vulkan/vn_physical_device.c index f7b75068934..7f2ae31d360 100644 --- a/src/virtio/vulkan/vn_physical_device.c +++ b/src/virtio/vulkan/vn_physical_device.c @@ -1048,14 +1048,14 @@ vn_physical_device_init_renderer_extensions( continue; /* check encoder support */ - const uint32_t spec_version = - vn_info_extension_spec_version(props->extensionName); - if (!spec_version) + const struct vn_info_extension *enc_ext = + vn_info_extension_get(props->extensionName); + if (!enc_ext) continue; physical_dev->renderer_extensions.extensions[i] = true; physical_dev->extension_spec_versions[i] = - MIN2(exts[j].specVersion, spec_version); + MIN2(exts[j].specVersion, enc_ext->spec_version); break; }