| /* This file is generated by venus-protocol. See vn_protocol_renderer.h. */ |
| |
| /* |
| * Copyright 2020 Google LLC |
| * SPDX-License-Identifier: MIT |
| */ |
| |
| #ifndef VN_PROTOCOL_RENDERER_COMMAND_BUFFER_H |
| #define VN_PROTOCOL_RENDERER_COMMAND_BUFFER_H |
| |
| #include "vn_protocol_renderer_structs.h" |
| |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wpointer-arith" |
| #pragma GCC diagnostic ignored "-Wunused-parameter" |
| |
| /* struct VkCommandBufferAllocateInfo chain */ |
| |
| static inline void * |
| vn_decode_VkCommandBufferAllocateInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkCommandBufferAllocateInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferAllocateInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkCommandPool_lookup(dec, &val->commandPool); |
| vn_decode_VkCommandBufferLevel(dec, &val->level); |
| vn_decode_uint32_t(dec, &val->commandBufferCount); |
| } |
| |
| static inline void |
| vn_decode_VkCommandBufferAllocateInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferAllocateInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkCommandBufferAllocateInfo_pnext_temp(dec); |
| vn_decode_VkCommandBufferAllocateInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkCommandBufferAllocateInfo_handle_self(VkCommandBufferAllocateInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| vn_replace_VkCommandPool_handle(&val->commandPool); |
| /* skip val->level */ |
| /* skip val->commandBufferCount */ |
| } |
| |
| static inline void |
| vn_replace_VkCommandBufferAllocateInfo_handle(VkCommandBufferAllocateInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: |
| vn_replace_VkCommandBufferAllocateInfo_handle_self((VkCommandBufferAllocateInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkCommandBufferInheritanceInfo chain */ |
| |
| static inline void |
| vn_encode_VkCommandBufferInheritanceInfo_pnext(struct vn_cs_encoder *enc, const void *val) |
| { |
| /* no known/supported struct */ |
| vn_encode_simple_pointer(enc, NULL); |
| } |
| |
| static inline void |
| vn_encode_VkCommandBufferInheritanceInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_encode_VkRenderPass(enc, &val->renderPass); |
| vn_encode_uint32_t(enc, &val->subpass); |
| vn_encode_VkFramebuffer(enc, &val->framebuffer); |
| vn_encode_VkBool32(enc, &val->occlusionQueryEnable); |
| vn_encode_VkFlags(enc, &val->queryFlags); |
| vn_encode_VkFlags(enc, &val->pipelineStatistics); |
| } |
| |
| static inline void |
| vn_encode_VkCommandBufferInheritanceInfo(struct vn_cs_encoder *enc, const VkCommandBufferInheritanceInfo *val) |
| { |
| assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO); |
| vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO }); |
| vn_encode_VkCommandBufferInheritanceInfo_pnext(enc, val->pNext); |
| vn_encode_VkCommandBufferInheritanceInfo_self(enc, val); |
| } |
| |
| static inline void * |
| vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkCommandBufferInheritanceInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkRenderPass_lookup(dec, &val->renderPass); |
| vn_decode_uint32_t(dec, &val->subpass); |
| vn_decode_VkFramebuffer_lookup(dec, &val->framebuffer); |
| vn_decode_VkBool32(dec, &val->occlusionQueryEnable); |
| vn_decode_VkFlags(dec, &val->queryFlags); |
| vn_decode_VkFlags(dec, &val->pipelineStatistics); |
| } |
| |
| static inline void |
| vn_decode_VkCommandBufferInheritanceInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(dec); |
| vn_decode_VkCommandBufferInheritanceInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkCommandBufferInheritanceInfo_handle_self(VkCommandBufferInheritanceInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| vn_replace_VkRenderPass_handle(&val->renderPass); |
| /* skip val->subpass */ |
| vn_replace_VkFramebuffer_handle(&val->framebuffer); |
| /* skip val->occlusionQueryEnable */ |
| /* skip val->queryFlags */ |
| /* skip val->pipelineStatistics */ |
| } |
| |
| static inline void |
| vn_replace_VkCommandBufferInheritanceInfo_handle(VkCommandBufferInheritanceInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: |
| vn_replace_VkCommandBufferInheritanceInfo_handle_self((VkCommandBufferInheritanceInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkDeviceGroupCommandBufferBeginInfo chain */ |
| |
| static inline void |
| vn_encode_VkDeviceGroupCommandBufferBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val) |
| { |
| /* no known/supported struct */ |
| vn_encode_simple_pointer(enc, NULL); |
| } |
| |
| static inline void |
| vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupCommandBufferBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_encode_uint32_t(enc, &val->deviceMask); |
| } |
| |
| static inline void |
| vn_encode_VkDeviceGroupCommandBufferBeginInfo(struct vn_cs_encoder *enc, const VkDeviceGroupCommandBufferBeginInfo *val) |
| { |
| assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO); |
| vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO }); |
| vn_encode_VkDeviceGroupCommandBufferBeginInfo_pnext(enc, val->pNext); |
| vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(enc, val); |
| } |
| |
| static inline void * |
| vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_uint32_t(dec, &val->deviceMask); |
| } |
| |
| static inline void |
| vn_decode_VkDeviceGroupCommandBufferBeginInfo_temp(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext_temp(dec); |
| vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self(VkDeviceGroupCommandBufferBeginInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->deviceMask */ |
| } |
| |
| static inline void |
| vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle(VkDeviceGroupCommandBufferBeginInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: |
| vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self((VkDeviceGroupCommandBufferBeginInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkCommandBufferBeginInfo chain */ |
| |
| static inline void |
| vn_encode_VkCommandBufferBeginInfo_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_COMMAND_BUFFER_BEGIN_INFO: |
| vn_encode_simple_pointer(enc, pnext); |
| vn_encode_VkStructureType(enc, &pnext->sType); |
| vn_encode_VkCommandBufferBeginInfo_pnext(enc, pnext->pNext); |
| vn_encode_VkDeviceGroupCommandBufferBeginInfo_self(enc, (const VkDeviceGroupCommandBufferBeginInfo *)pnext); |
| return; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } |
| |
| vn_encode_simple_pointer(enc, NULL); |
| } |
| |
| static inline void |
| vn_encode_VkCommandBufferBeginInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_encode_VkFlags(enc, &val->flags); |
| if (vn_encode_simple_pointer(enc, val->pInheritanceInfo)) |
| vn_encode_VkCommandBufferInheritanceInfo(enc, val->pInheritanceInfo); |
| } |
| |
| static inline void |
| vn_encode_VkCommandBufferBeginInfo(struct vn_cs_encoder *enc, const VkCommandBufferBeginInfo *val) |
| { |
| assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO); |
| vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }); |
| vn_encode_VkCommandBufferBeginInfo_pnext(enc, val->pNext); |
| vn_encode_VkCommandBufferBeginInfo_self(enc, val); |
| } |
| |
| static inline void * |
| vn_decode_VkCommandBufferBeginInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| VkBaseOutStructure *pnext; |
| VkStructureType stype; |
| |
| if (!vn_decode_simple_pointer(dec)) |
| return NULL; |
| |
| vn_decode_VkStructureType(dec, &stype); |
| switch ((int32_t)stype) { |
| case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: |
| pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDeviceGroupCommandBufferBeginInfo)); |
| if (pnext) { |
| pnext->sType = stype; |
| pnext->pNext = vn_decode_VkCommandBufferBeginInfo_pnext_temp(dec); |
| vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(dec, (VkDeviceGroupCommandBufferBeginInfo *)pnext); |
| } |
| break; |
| default: |
| /* unexpected struct */ |
| pnext = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| break; |
| } |
| |
| return pnext; |
| } |
| |
| static inline void |
| vn_decode_VkCommandBufferBeginInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkFlags(dec, &val->flags); |
| if (vn_decode_simple_pointer(dec)) { |
| val->pInheritanceInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pInheritanceInfo)); |
| if (!val->pInheritanceInfo) return; |
| vn_decode_VkCommandBufferInheritanceInfo_temp(dec, (VkCommandBufferInheritanceInfo *)val->pInheritanceInfo); |
| } else { |
| val->pInheritanceInfo = NULL; |
| } |
| } |
| |
| static inline void |
| vn_decode_VkCommandBufferBeginInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkCommandBufferBeginInfo_pnext_temp(dec); |
| vn_decode_VkCommandBufferBeginInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkCommandBufferBeginInfo_handle_self(VkCommandBufferBeginInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->flags */ |
| if (val->pInheritanceInfo) |
| vn_replace_VkCommandBufferInheritanceInfo_handle((VkCommandBufferInheritanceInfo *)val->pInheritanceInfo); |
| } |
| |
| static inline void |
| vn_replace_VkCommandBufferBeginInfo_handle(VkCommandBufferBeginInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: |
| vn_replace_VkCommandBufferBeginInfo_handle_self((VkCommandBufferBeginInfo *)pnext); |
| break; |
| case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: |
| vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self((VkDeviceGroupCommandBufferBeginInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkBufferCopy */ |
| |
| static inline void |
| vn_decode_VkBufferCopy_temp(struct vn_cs_decoder *dec, VkBufferCopy *val) |
| { |
| vn_decode_VkDeviceSize(dec, &val->srcOffset); |
| vn_decode_VkDeviceSize(dec, &val->dstOffset); |
| vn_decode_VkDeviceSize(dec, &val->size); |
| } |
| |
| static inline void |
| vn_replace_VkBufferCopy_handle(VkBufferCopy *val) |
| { |
| /* skip val->srcOffset */ |
| /* skip val->dstOffset */ |
| /* skip val->size */ |
| } |
| |
| /* struct VkImageSubresourceLayers */ |
| |
| static inline void |
| vn_decode_VkImageSubresourceLayers_temp(struct vn_cs_decoder *dec, VkImageSubresourceLayers *val) |
| { |
| vn_decode_VkFlags(dec, &val->aspectMask); |
| vn_decode_uint32_t(dec, &val->mipLevel); |
| vn_decode_uint32_t(dec, &val->baseArrayLayer); |
| vn_decode_uint32_t(dec, &val->layerCount); |
| } |
| |
| static inline void |
| vn_replace_VkImageSubresourceLayers_handle(VkImageSubresourceLayers *val) |
| { |
| /* skip val->aspectMask */ |
| /* skip val->mipLevel */ |
| /* skip val->baseArrayLayer */ |
| /* skip val->layerCount */ |
| } |
| |
| /* struct VkImageCopy */ |
| |
| static inline void |
| vn_decode_VkImageCopy_temp(struct vn_cs_decoder *dec, VkImageCopy *val) |
| { |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource); |
| vn_decode_VkOffset3D_temp(dec, &val->srcOffset); |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource); |
| vn_decode_VkOffset3D_temp(dec, &val->dstOffset); |
| vn_decode_VkExtent3D_temp(dec, &val->extent); |
| } |
| |
| static inline void |
| vn_replace_VkImageCopy_handle(VkImageCopy *val) |
| { |
| vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource); |
| vn_replace_VkOffset3D_handle(&val->srcOffset); |
| vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource); |
| vn_replace_VkOffset3D_handle(&val->dstOffset); |
| vn_replace_VkExtent3D_handle(&val->extent); |
| } |
| |
| /* struct VkImageBlit */ |
| |
| static inline void |
| vn_decode_VkImageBlit_temp(struct vn_cs_decoder *dec, VkImageBlit *val) |
| { |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource); |
| { |
| const uint32_t iter_count = vn_decode_array_size(dec, 2); |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkOffset3D_temp(dec, &val->srcOffsets[i]); |
| } |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource); |
| { |
| const uint32_t iter_count = vn_decode_array_size(dec, 2); |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkOffset3D_temp(dec, &val->dstOffsets[i]); |
| } |
| } |
| |
| static inline void |
| vn_replace_VkImageBlit_handle(VkImageBlit *val) |
| { |
| vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource); |
| for (uint32_t i = 0; i < 2; i++) |
| vn_replace_VkOffset3D_handle(&val->srcOffsets[i]); |
| vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource); |
| for (uint32_t i = 0; i < 2; i++) |
| vn_replace_VkOffset3D_handle(&val->dstOffsets[i]); |
| } |
| |
| /* struct VkBufferImageCopy */ |
| |
| static inline void |
| vn_decode_VkBufferImageCopy_temp(struct vn_cs_decoder *dec, VkBufferImageCopy *val) |
| { |
| vn_decode_VkDeviceSize(dec, &val->bufferOffset); |
| vn_decode_uint32_t(dec, &val->bufferRowLength); |
| vn_decode_uint32_t(dec, &val->bufferImageHeight); |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->imageSubresource); |
| vn_decode_VkOffset3D_temp(dec, &val->imageOffset); |
| vn_decode_VkExtent3D_temp(dec, &val->imageExtent); |
| } |
| |
| static inline void |
| vn_replace_VkBufferImageCopy_handle(VkBufferImageCopy *val) |
| { |
| /* skip val->bufferOffset */ |
| /* skip val->bufferRowLength */ |
| /* skip val->bufferImageHeight */ |
| vn_replace_VkImageSubresourceLayers_handle(&val->imageSubresource); |
| vn_replace_VkOffset3D_handle(&val->imageOffset); |
| vn_replace_VkExtent3D_handle(&val->imageExtent); |
| } |
| |
| /* union VkClearColorValue */ |
| |
| static inline void |
| vn_decode_VkClearColorValue_temp(struct vn_cs_decoder *dec, VkClearColorValue *val) |
| { |
| uint32_t tag; |
| vn_decode_uint32_t(dec, &tag); |
| switch (tag) { |
| case 0: |
| { |
| const size_t array_size = vn_decode_array_size(dec, 4); |
| vn_decode_float_array(dec, val->float32, array_size); |
| } |
| break; |
| case 1: |
| { |
| const size_t array_size = vn_decode_array_size(dec, 4); |
| vn_decode_int32_t_array(dec, val->int32, array_size); |
| } |
| break; |
| case 2: |
| { |
| const size_t array_size = vn_decode_array_size(dec, 4); |
| vn_decode_uint32_t_array(dec, val->uint32, array_size); |
| } |
| break; |
| default: |
| vn_cs_decoder_set_fatal(dec); |
| break; |
| } |
| } |
| |
| /* struct VkClearDepthStencilValue */ |
| |
| static inline void |
| vn_decode_VkClearDepthStencilValue_temp(struct vn_cs_decoder *dec, VkClearDepthStencilValue *val) |
| { |
| vn_decode_float(dec, &val->depth); |
| vn_decode_uint32_t(dec, &val->stencil); |
| } |
| |
| static inline void |
| vn_replace_VkClearDepthStencilValue_handle(VkClearDepthStencilValue *val) |
| { |
| /* skip val->depth */ |
| /* skip val->stencil */ |
| } |
| |
| /* union VkClearValue */ |
| |
| static inline void |
| vn_decode_VkClearValue_temp(struct vn_cs_decoder *dec, VkClearValue *val) |
| { |
| uint32_t tag; |
| vn_decode_uint32_t(dec, &tag); |
| switch (tag) { |
| case 0: |
| vn_decode_VkClearColorValue_temp(dec, &val->color); |
| break; |
| case 1: |
| vn_decode_VkClearDepthStencilValue_temp(dec, &val->depthStencil); |
| break; |
| default: |
| vn_cs_decoder_set_fatal(dec); |
| break; |
| } |
| } |
| |
| /* struct VkClearAttachment */ |
| |
| static inline void |
| vn_decode_VkClearAttachment_temp(struct vn_cs_decoder *dec, VkClearAttachment *val) |
| { |
| vn_decode_VkFlags(dec, &val->aspectMask); |
| vn_decode_uint32_t(dec, &val->colorAttachment); |
| vn_decode_VkClearValue_temp(dec, &val->clearValue); |
| } |
| |
| static inline void |
| vn_replace_VkClearAttachment_handle(VkClearAttachment *val) |
| { |
| /* skip val->aspectMask */ |
| /* skip val->colorAttachment */ |
| /* skip val->clearValue */ |
| } |
| |
| /* struct VkClearRect */ |
| |
| static inline void |
| vn_decode_VkClearRect_temp(struct vn_cs_decoder *dec, VkClearRect *val) |
| { |
| vn_decode_VkRect2D_temp(dec, &val->rect); |
| vn_decode_uint32_t(dec, &val->baseArrayLayer); |
| vn_decode_uint32_t(dec, &val->layerCount); |
| } |
| |
| static inline void |
| vn_replace_VkClearRect_handle(VkClearRect *val) |
| { |
| vn_replace_VkRect2D_handle(&val->rect); |
| /* skip val->baseArrayLayer */ |
| /* skip val->layerCount */ |
| } |
| |
| /* struct VkImageResolve */ |
| |
| static inline void |
| vn_decode_VkImageResolve_temp(struct vn_cs_decoder *dec, VkImageResolve *val) |
| { |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource); |
| vn_decode_VkOffset3D_temp(dec, &val->srcOffset); |
| vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource); |
| vn_decode_VkOffset3D_temp(dec, &val->dstOffset); |
| vn_decode_VkExtent3D_temp(dec, &val->extent); |
| } |
| |
| static inline void |
| vn_replace_VkImageResolve_handle(VkImageResolve *val) |
| { |
| vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource); |
| vn_replace_VkOffset3D_handle(&val->srcOffset); |
| vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource); |
| vn_replace_VkOffset3D_handle(&val->dstOffset); |
| vn_replace_VkExtent3D_handle(&val->extent); |
| } |
| |
| /* struct VkMemoryBarrier chain */ |
| |
| static inline void * |
| vn_decode_VkMemoryBarrier_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkMemoryBarrier_self_temp(struct vn_cs_decoder *dec, VkMemoryBarrier *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkFlags(dec, &val->srcAccessMask); |
| vn_decode_VkFlags(dec, &val->dstAccessMask); |
| } |
| |
| static inline void |
| vn_decode_VkMemoryBarrier_temp(struct vn_cs_decoder *dec, VkMemoryBarrier *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_MEMORY_BARRIER) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkMemoryBarrier_pnext_temp(dec); |
| vn_decode_VkMemoryBarrier_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkMemoryBarrier_handle_self(VkMemoryBarrier *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->srcAccessMask */ |
| /* skip val->dstAccessMask */ |
| } |
| |
| static inline void |
| vn_replace_VkMemoryBarrier_handle(VkMemoryBarrier *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_MEMORY_BARRIER: |
| vn_replace_VkMemoryBarrier_handle_self((VkMemoryBarrier *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkBufferMemoryBarrier chain */ |
| |
| static inline void * |
| vn_decode_VkBufferMemoryBarrier_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkBufferMemoryBarrier_self_temp(struct vn_cs_decoder *dec, VkBufferMemoryBarrier *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkFlags(dec, &val->srcAccessMask); |
| vn_decode_VkFlags(dec, &val->dstAccessMask); |
| vn_decode_uint32_t(dec, &val->srcQueueFamilyIndex); |
| vn_decode_uint32_t(dec, &val->dstQueueFamilyIndex); |
| vn_decode_VkBuffer_lookup(dec, &val->buffer); |
| vn_decode_VkDeviceSize(dec, &val->offset); |
| vn_decode_VkDeviceSize(dec, &val->size); |
| } |
| |
| static inline void |
| vn_decode_VkBufferMemoryBarrier_temp(struct vn_cs_decoder *dec, VkBufferMemoryBarrier *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkBufferMemoryBarrier_pnext_temp(dec); |
| vn_decode_VkBufferMemoryBarrier_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkBufferMemoryBarrier_handle_self(VkBufferMemoryBarrier *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->srcAccessMask */ |
| /* skip val->dstAccessMask */ |
| /* skip val->srcQueueFamilyIndex */ |
| /* skip val->dstQueueFamilyIndex */ |
| vn_replace_VkBuffer_handle(&val->buffer); |
| /* skip val->offset */ |
| /* skip val->size */ |
| } |
| |
| static inline void |
| vn_replace_VkBufferMemoryBarrier_handle(VkBufferMemoryBarrier *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: |
| vn_replace_VkBufferMemoryBarrier_handle_self((VkBufferMemoryBarrier *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkImageMemoryBarrier chain */ |
| |
| static inline void * |
| vn_decode_VkImageMemoryBarrier_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkImageMemoryBarrier_self_temp(struct vn_cs_decoder *dec, VkImageMemoryBarrier *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkFlags(dec, &val->srcAccessMask); |
| vn_decode_VkFlags(dec, &val->dstAccessMask); |
| vn_decode_VkImageLayout(dec, &val->oldLayout); |
| vn_decode_VkImageLayout(dec, &val->newLayout); |
| vn_decode_uint32_t(dec, &val->srcQueueFamilyIndex); |
| vn_decode_uint32_t(dec, &val->dstQueueFamilyIndex); |
| vn_decode_VkImage_lookup(dec, &val->image); |
| vn_decode_VkImageSubresourceRange_temp(dec, &val->subresourceRange); |
| } |
| |
| static inline void |
| vn_decode_VkImageMemoryBarrier_temp(struct vn_cs_decoder *dec, VkImageMemoryBarrier *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkImageMemoryBarrier_pnext_temp(dec); |
| vn_decode_VkImageMemoryBarrier_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkImageMemoryBarrier_handle_self(VkImageMemoryBarrier *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->srcAccessMask */ |
| /* skip val->dstAccessMask */ |
| /* skip val->oldLayout */ |
| /* skip val->newLayout */ |
| /* skip val->srcQueueFamilyIndex */ |
| /* skip val->dstQueueFamilyIndex */ |
| vn_replace_VkImage_handle(&val->image); |
| vn_replace_VkImageSubresourceRange_handle(&val->subresourceRange); |
| } |
| |
| static inline void |
| vn_replace_VkImageMemoryBarrier_handle(VkImageMemoryBarrier *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: |
| vn_replace_VkImageMemoryBarrier_handle_self((VkImageMemoryBarrier *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkDeviceGroupRenderPassBeginInfo chain */ |
| |
| static inline void * |
| vn_decode_VkDeviceGroupRenderPassBeginInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceGroupRenderPassBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_uint32_t(dec, &val->deviceMask); |
| vn_decode_uint32_t(dec, &val->deviceRenderAreaCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, val->deviceRenderAreaCount); |
| val->pDeviceRenderAreas = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDeviceRenderAreas) * iter_count); |
| if (!val->pDeviceRenderAreas) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkRect2D_temp(dec, &((VkRect2D *)val->pDeviceRenderAreas)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| val->pDeviceRenderAreas = NULL; |
| } |
| } |
| |
| static inline void |
| vn_decode_VkDeviceGroupRenderPassBeginInfo_temp(struct vn_cs_decoder *dec, VkDeviceGroupRenderPassBeginInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkDeviceGroupRenderPassBeginInfo_pnext_temp(dec); |
| vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self(VkDeviceGroupRenderPassBeginInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->deviceMask */ |
| /* skip val->deviceRenderAreaCount */ |
| if (val->pDeviceRenderAreas) { |
| for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++) |
| vn_replace_VkRect2D_handle(&((VkRect2D *)val->pDeviceRenderAreas)[i]); |
| } |
| } |
| |
| static inline void |
| vn_replace_VkDeviceGroupRenderPassBeginInfo_handle(VkDeviceGroupRenderPassBeginInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: |
| vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self((VkDeviceGroupRenderPassBeginInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkRenderPassAttachmentBeginInfo chain */ |
| |
| static inline void * |
| vn_decode_VkRenderPassAttachmentBeginInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(struct vn_cs_decoder *dec, VkRenderPassAttachmentBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_uint32_t(dec, &val->attachmentCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, val->attachmentCount); |
| val->pAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pAttachments) * iter_count); |
| if (!val->pAttachments) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageView_lookup(dec, &((VkImageView *)val->pAttachments)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| val->pAttachments = NULL; |
| } |
| } |
| |
| static inline void |
| vn_decode_VkRenderPassAttachmentBeginInfo_temp(struct vn_cs_decoder *dec, VkRenderPassAttachmentBeginInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkRenderPassAttachmentBeginInfo_pnext_temp(dec); |
| vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkRenderPassAttachmentBeginInfo_handle_self(VkRenderPassAttachmentBeginInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->attachmentCount */ |
| if (val->pAttachments) { |
| for (uint32_t i = 0; i < val->attachmentCount; i++) |
| vn_replace_VkImageView_handle(&((VkImageView *)val->pAttachments)[i]); |
| } |
| } |
| |
| static inline void |
| vn_replace_VkRenderPassAttachmentBeginInfo_handle(VkRenderPassAttachmentBeginInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: |
| vn_replace_VkRenderPassAttachmentBeginInfo_handle_self((VkRenderPassAttachmentBeginInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkRenderPassBeginInfo chain */ |
| |
| static inline void * |
| vn_decode_VkRenderPassBeginInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| VkBaseOutStructure *pnext; |
| VkStructureType stype; |
| |
| if (!vn_decode_simple_pointer(dec)) |
| return NULL; |
| |
| vn_decode_VkStructureType(dec, &stype); |
| switch ((int32_t)stype) { |
| case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: |
| pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDeviceGroupRenderPassBeginInfo)); |
| if (pnext) { |
| pnext->sType = stype; |
| pnext->pNext = vn_decode_VkRenderPassBeginInfo_pnext_temp(dec); |
| vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(dec, (VkDeviceGroupRenderPassBeginInfo *)pnext); |
| } |
| break; |
| case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: |
| pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkRenderPassAttachmentBeginInfo)); |
| if (pnext) { |
| pnext->sType = stype; |
| pnext->pNext = vn_decode_VkRenderPassBeginInfo_pnext_temp(dec); |
| vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(dec, (VkRenderPassAttachmentBeginInfo *)pnext); |
| } |
| break; |
| default: |
| /* unexpected struct */ |
| pnext = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| break; |
| } |
| |
| return pnext; |
| } |
| |
| static inline void |
| vn_decode_VkRenderPassBeginInfo_self_temp(struct vn_cs_decoder *dec, VkRenderPassBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkRenderPass_lookup(dec, &val->renderPass); |
| vn_decode_VkFramebuffer_lookup(dec, &val->framebuffer); |
| vn_decode_VkRect2D_temp(dec, &val->renderArea); |
| vn_decode_uint32_t(dec, &val->clearValueCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, val->clearValueCount); |
| val->pClearValues = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pClearValues) * iter_count); |
| if (!val->pClearValues) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkClearValue_temp(dec, &((VkClearValue *)val->pClearValues)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| val->pClearValues = NULL; |
| } |
| } |
| |
| static inline void |
| vn_decode_VkRenderPassBeginInfo_temp(struct vn_cs_decoder *dec, VkRenderPassBeginInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkRenderPassBeginInfo_pnext_temp(dec); |
| vn_decode_VkRenderPassBeginInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkRenderPassBeginInfo_handle_self(VkRenderPassBeginInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| vn_replace_VkRenderPass_handle(&val->renderPass); |
| vn_replace_VkFramebuffer_handle(&val->framebuffer); |
| vn_replace_VkRect2D_handle(&val->renderArea); |
| /* skip val->clearValueCount */ |
| /* skip val->pClearValues */ |
| } |
| |
| static inline void |
| vn_replace_VkRenderPassBeginInfo_handle(VkRenderPassBeginInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: |
| vn_replace_VkRenderPassBeginInfo_handle_self((VkRenderPassBeginInfo *)pnext); |
| break; |
| case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: |
| vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self((VkDeviceGroupRenderPassBeginInfo *)pnext); |
| break; |
| case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: |
| vn_replace_VkRenderPassAttachmentBeginInfo_handle_self((VkRenderPassAttachmentBeginInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkSubpassBeginInfo chain */ |
| |
| static inline void * |
| vn_decode_VkSubpassBeginInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkSubpassBeginInfo_self_temp(struct vn_cs_decoder *dec, VkSubpassBeginInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| vn_decode_VkSubpassContents(dec, &val->contents); |
| } |
| |
| static inline void |
| vn_decode_VkSubpassBeginInfo_temp(struct vn_cs_decoder *dec, VkSubpassBeginInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkSubpassBeginInfo_pnext_temp(dec); |
| vn_decode_VkSubpassBeginInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkSubpassBeginInfo_handle_self(VkSubpassBeginInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| /* skip val->contents */ |
| } |
| |
| static inline void |
| vn_replace_VkSubpassBeginInfo_handle(VkSubpassBeginInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: |
| vn_replace_VkSubpassBeginInfo_handle_self((VkSubpassBeginInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| /* struct VkSubpassEndInfo chain */ |
| |
| static inline void * |
| vn_decode_VkSubpassEndInfo_pnext_temp(struct vn_cs_decoder *dec) |
| { |
| /* no known/supported struct */ |
| if (vn_decode_simple_pointer(dec)) |
| vn_cs_decoder_set_fatal(dec); |
| return NULL; |
| } |
| |
| static inline void |
| vn_decode_VkSubpassEndInfo_self_temp(struct vn_cs_decoder *dec, VkSubpassEndInfo *val) |
| { |
| /* skip val->{sType,pNext} */ |
| } |
| |
| static inline void |
| vn_decode_VkSubpassEndInfo_temp(struct vn_cs_decoder *dec, VkSubpassEndInfo *val) |
| { |
| VkStructureType stype; |
| vn_decode_VkStructureType(dec, &stype); |
| if (stype != VK_STRUCTURE_TYPE_SUBPASS_END_INFO) |
| vn_cs_decoder_set_fatal(dec); |
| |
| val->sType = stype; |
| val->pNext = vn_decode_VkSubpassEndInfo_pnext_temp(dec); |
| vn_decode_VkSubpassEndInfo_self_temp(dec, val); |
| } |
| |
| static inline void |
| vn_replace_VkSubpassEndInfo_handle_self(VkSubpassEndInfo *val) |
| { |
| /* skip val->sType */ |
| /* skip val->pNext */ |
| } |
| |
| static inline void |
| vn_replace_VkSubpassEndInfo_handle(VkSubpassEndInfo *val) |
| { |
| struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val; |
| |
| do { |
| switch ((int32_t)pnext->sType) { |
| case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: |
| vn_replace_VkSubpassEndInfo_handle_self((VkSubpassEndInfo *)pnext); |
| break; |
| default: |
| /* ignore unknown/unsupported struct */ |
| break; |
| } |
| pnext = pnext->pNext; |
| } while (pnext); |
| } |
| |
| static inline void vn_decode_vkAllocateCommandBuffers_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkAllocateCommandBuffers *args) |
| { |
| vn_decode_VkDevice_lookup(dec, &args->device); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pAllocateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pAllocateInfo)); |
| if (!args->pAllocateInfo) return; |
| vn_decode_VkCommandBufferAllocateInfo_temp(dec, (VkCommandBufferAllocateInfo *)args->pAllocateInfo); |
| } else { |
| args->pAllocateInfo = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0)); |
| args->pCommandBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCommandBuffers) * iter_count); |
| if (!args->pCommandBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkCommandBuffer_temp(dec, &args->pCommandBuffers[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCommandBuffers = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkAllocateCommandBuffers_args_handle(struct vn_command_vkAllocateCommandBuffers *args) |
| { |
| vn_replace_VkDevice_handle(&args->device); |
| if (args->pAllocateInfo) |
| vn_replace_VkCommandBufferAllocateInfo_handle((VkCommandBufferAllocateInfo *)args->pAllocateInfo); |
| /* skip args->pCommandBuffers */ |
| } |
| |
| static inline void vn_encode_vkAllocateCommandBuffers_reply(struct vn_cs_encoder *enc, const struct vn_command_vkAllocateCommandBuffers *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT}); |
| |
| vn_encode_VkResult(enc, &args->ret); |
| /* skip args->device */ |
| /* skip args->pAllocateInfo */ |
| if (args->pCommandBuffers) { |
| vn_encode_array_size(enc, (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0)); |
| for (uint32_t i = 0; i < (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0); i++) |
| vn_encode_VkCommandBuffer(enc, &args->pCommandBuffers[i]); |
| } else { |
| vn_encode_array_size(enc, 0); |
| } |
| } |
| |
| static inline void vn_decode_vkFreeCommandBuffers_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkFreeCommandBuffers *args) |
| { |
| vn_decode_VkDevice_lookup(dec, &args->device); |
| vn_decode_VkCommandPool_lookup(dec, &args->commandPool); |
| vn_decode_uint32_t(dec, &args->commandBufferCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->commandBufferCount); |
| args->pCommandBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCommandBuffers) * iter_count); |
| if (!args->pCommandBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkCommandBuffer_lookup(dec, &((VkCommandBuffer *)args->pCommandBuffers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCommandBuffers = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkFreeCommandBuffers_args_handle(struct vn_command_vkFreeCommandBuffers *args) |
| { |
| vn_replace_VkDevice_handle(&args->device); |
| vn_replace_VkCommandPool_handle(&args->commandPool); |
| /* skip args->commandBufferCount */ |
| if (args->pCommandBuffers) { |
| for (uint32_t i = 0; i < args->commandBufferCount; i++) |
| vn_replace_VkCommandBuffer_handle(&((VkCommandBuffer *)args->pCommandBuffers)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkFreeCommandBuffers_reply(struct vn_cs_encoder *enc, const struct vn_command_vkFreeCommandBuffers *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT}); |
| |
| /* skip args->device */ |
| /* skip args->commandPool */ |
| /* skip args->commandBufferCount */ |
| /* skip args->pCommandBuffers */ |
| } |
| |
| static inline void vn_decode_vkBeginCommandBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkBeginCommandBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pBeginInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBeginInfo)); |
| if (!args->pBeginInfo) return; |
| vn_decode_VkCommandBufferBeginInfo_temp(dec, (VkCommandBufferBeginInfo *)args->pBeginInfo); |
| } else { |
| args->pBeginInfo = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| } |
| |
| static inline void vn_replace_vkBeginCommandBuffer_args_handle(struct vn_command_vkBeginCommandBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| if (args->pBeginInfo) |
| vn_replace_VkCommandBufferBeginInfo_handle((VkCommandBufferBeginInfo *)args->pBeginInfo); |
| } |
| |
| static inline void vn_encode_vkBeginCommandBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkBeginCommandBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT}); |
| |
| vn_encode_VkResult(enc, &args->ret); |
| /* skip args->commandBuffer */ |
| /* skip args->pBeginInfo */ |
| } |
| |
| static inline void vn_decode_vkEndCommandBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkEndCommandBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| } |
| |
| static inline void vn_replace_vkEndCommandBuffer_args_handle(struct vn_command_vkEndCommandBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| } |
| |
| static inline void vn_encode_vkEndCommandBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkEndCommandBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkEndCommandBuffer_EXT}); |
| |
| vn_encode_VkResult(enc, &args->ret); |
| /* skip args->commandBuffer */ |
| } |
| |
| static inline void vn_decode_vkResetCommandBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkResetCommandBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkFlags(dec, &args->flags); |
| } |
| |
| static inline void vn_replace_vkResetCommandBuffer_args_handle(struct vn_command_vkResetCommandBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->flags */ |
| } |
| |
| static inline void vn_encode_vkResetCommandBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkResetCommandBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkResetCommandBuffer_EXT}); |
| |
| vn_encode_VkResult(enc, &args->ret); |
| /* skip args->commandBuffer */ |
| /* skip args->flags */ |
| } |
| |
| static inline void vn_decode_vkCmdBindPipeline_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindPipeline *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkPipelineBindPoint(dec, &args->pipelineBindPoint); |
| vn_decode_VkPipeline_lookup(dec, &args->pipeline); |
| } |
| |
| static inline void vn_replace_vkCmdBindPipeline_args_handle(struct vn_command_vkCmdBindPipeline *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->pipelineBindPoint */ |
| vn_replace_VkPipeline_handle(&args->pipeline); |
| } |
| |
| static inline void vn_encode_vkCmdBindPipeline_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindPipeline *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindPipeline_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pipelineBindPoint */ |
| /* skip args->pipeline */ |
| } |
| |
| static inline void vn_decode_vkCmdSetViewport_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetViewport *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->firstViewport); |
| vn_decode_uint32_t(dec, &args->viewportCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->viewportCount); |
| args->pViewports = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pViewports) * iter_count); |
| if (!args->pViewports) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkViewport_temp(dec, &((VkViewport *)args->pViewports)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pViewports = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdSetViewport_args_handle(struct vn_command_vkCmdSetViewport *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->firstViewport */ |
| /* skip args->viewportCount */ |
| if (args->pViewports) { |
| for (uint32_t i = 0; i < args->viewportCount; i++) |
| vn_replace_VkViewport_handle(&((VkViewport *)args->pViewports)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdSetViewport_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetViewport *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetViewport_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->firstViewport */ |
| /* skip args->viewportCount */ |
| /* skip args->pViewports */ |
| } |
| |
| static inline void vn_decode_vkCmdSetScissor_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetScissor *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->firstScissor); |
| vn_decode_uint32_t(dec, &args->scissorCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->scissorCount); |
| args->pScissors = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pScissors) * iter_count); |
| if (!args->pScissors) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkRect2D_temp(dec, &((VkRect2D *)args->pScissors)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pScissors = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdSetScissor_args_handle(struct vn_command_vkCmdSetScissor *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->firstScissor */ |
| /* skip args->scissorCount */ |
| if (args->pScissors) { |
| for (uint32_t i = 0; i < args->scissorCount; i++) |
| vn_replace_VkRect2D_handle(&((VkRect2D *)args->pScissors)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdSetScissor_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetScissor *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetScissor_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->firstScissor */ |
| /* skip args->scissorCount */ |
| /* skip args->pScissors */ |
| } |
| |
| static inline void vn_decode_vkCmdSetLineWidth_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetLineWidth *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_float(dec, &args->lineWidth); |
| } |
| |
| static inline void vn_replace_vkCmdSetLineWidth_args_handle(struct vn_command_vkCmdSetLineWidth *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->lineWidth */ |
| } |
| |
| static inline void vn_encode_vkCmdSetLineWidth_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetLineWidth *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->lineWidth */ |
| } |
| |
| static inline void vn_decode_vkCmdSetDepthBias_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthBias *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_float(dec, &args->depthBiasConstantFactor); |
| vn_decode_float(dec, &args->depthBiasClamp); |
| vn_decode_float(dec, &args->depthBiasSlopeFactor); |
| } |
| |
| static inline void vn_replace_vkCmdSetDepthBias_args_handle(struct vn_command_vkCmdSetDepthBias *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->depthBiasConstantFactor */ |
| /* skip args->depthBiasClamp */ |
| /* skip args->depthBiasSlopeFactor */ |
| } |
| |
| static inline void vn_encode_vkCmdSetDepthBias_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthBias *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->depthBiasConstantFactor */ |
| /* skip args->depthBiasClamp */ |
| /* skip args->depthBiasSlopeFactor */ |
| } |
| |
| static inline void vn_decode_vkCmdSetBlendConstants_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetBlendConstants *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| { |
| const size_t array_size = vn_decode_array_size(dec, 4); |
| vn_decode_float_array(dec, (float *)args->blendConstants, array_size); |
| } |
| } |
| |
| static inline void vn_replace_vkCmdSetBlendConstants_args_handle(struct vn_command_vkCmdSetBlendConstants *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->blendConstants */ |
| } |
| |
| static inline void vn_encode_vkCmdSetBlendConstants_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetBlendConstants *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->blendConstants */ |
| } |
| |
| static inline void vn_decode_vkCmdSetDepthBounds_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthBounds *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_float(dec, &args->minDepthBounds); |
| vn_decode_float(dec, &args->maxDepthBounds); |
| } |
| |
| static inline void vn_replace_vkCmdSetDepthBounds_args_handle(struct vn_command_vkCmdSetDepthBounds *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->minDepthBounds */ |
| /* skip args->maxDepthBounds */ |
| } |
| |
| static inline void vn_encode_vkCmdSetDepthBounds_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthBounds *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->minDepthBounds */ |
| /* skip args->maxDepthBounds */ |
| } |
| |
| static inline void vn_decode_vkCmdSetStencilCompareMask_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilCompareMask *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkFlags(dec, &args->faceMask); |
| vn_decode_uint32_t(dec, &args->compareMask); |
| } |
| |
| static inline void vn_replace_vkCmdSetStencilCompareMask_args_handle(struct vn_command_vkCmdSetStencilCompareMask *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->faceMask */ |
| /* skip args->compareMask */ |
| } |
| |
| static inline void vn_encode_vkCmdSetStencilCompareMask_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilCompareMask *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->faceMask */ |
| /* skip args->compareMask */ |
| } |
| |
| static inline void vn_decode_vkCmdSetStencilWriteMask_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilWriteMask *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkFlags(dec, &args->faceMask); |
| vn_decode_uint32_t(dec, &args->writeMask); |
| } |
| |
| static inline void vn_replace_vkCmdSetStencilWriteMask_args_handle(struct vn_command_vkCmdSetStencilWriteMask *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->faceMask */ |
| /* skip args->writeMask */ |
| } |
| |
| static inline void vn_encode_vkCmdSetStencilWriteMask_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilWriteMask *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->faceMask */ |
| /* skip args->writeMask */ |
| } |
| |
| static inline void vn_decode_vkCmdSetStencilReference_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilReference *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkFlags(dec, &args->faceMask); |
| vn_decode_uint32_t(dec, &args->reference); |
| } |
| |
| static inline void vn_replace_vkCmdSetStencilReference_args_handle(struct vn_command_vkCmdSetStencilReference *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->faceMask */ |
| /* skip args->reference */ |
| } |
| |
| static inline void vn_encode_vkCmdSetStencilReference_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilReference *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->faceMask */ |
| /* skip args->reference */ |
| } |
| |
| static inline void vn_decode_vkCmdBindDescriptorSets_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindDescriptorSets *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkPipelineBindPoint(dec, &args->pipelineBindPoint); |
| vn_decode_VkPipelineLayout_lookup(dec, &args->layout); |
| vn_decode_uint32_t(dec, &args->firstSet); |
| vn_decode_uint32_t(dec, &args->descriptorSetCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->descriptorSetCount); |
| args->pDescriptorSets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDescriptorSets) * iter_count); |
| if (!args->pDescriptorSets) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkDescriptorSet_lookup(dec, &((VkDescriptorSet *)args->pDescriptorSets)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pDescriptorSets = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->dynamicOffsetCount); |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->dynamicOffsetCount); |
| args->pDynamicOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDynamicOffsets) * array_size); |
| if (!args->pDynamicOffsets) return; |
| vn_decode_uint32_t_array(dec, (uint32_t *)args->pDynamicOffsets, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pDynamicOffsets = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdBindDescriptorSets_args_handle(struct vn_command_vkCmdBindDescriptorSets *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->pipelineBindPoint */ |
| vn_replace_VkPipelineLayout_handle(&args->layout); |
| /* skip args->firstSet */ |
| /* skip args->descriptorSetCount */ |
| if (args->pDescriptorSets) { |
| for (uint32_t i = 0; i < args->descriptorSetCount; i++) |
| vn_replace_VkDescriptorSet_handle(&((VkDescriptorSet *)args->pDescriptorSets)[i]); |
| } |
| /* skip args->dynamicOffsetCount */ |
| /* skip args->pDynamicOffsets */ |
| } |
| |
| static inline void vn_encode_vkCmdBindDescriptorSets_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindDescriptorSets *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pipelineBindPoint */ |
| /* skip args->layout */ |
| /* skip args->firstSet */ |
| /* skip args->descriptorSetCount */ |
| /* skip args->pDescriptorSets */ |
| /* skip args->dynamicOffsetCount */ |
| /* skip args->pDynamicOffsets */ |
| } |
| |
| static inline void vn_decode_vkCmdBindIndexBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindIndexBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->buffer); |
| vn_decode_VkDeviceSize(dec, &args->offset); |
| vn_decode_VkIndexType(dec, &args->indexType); |
| } |
| |
| static inline void vn_replace_vkCmdBindIndexBuffer_args_handle(struct vn_command_vkCmdBindIndexBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->buffer); |
| /* skip args->offset */ |
| /* skip args->indexType */ |
| } |
| |
| static inline void vn_encode_vkCmdBindIndexBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindIndexBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->buffer */ |
| /* skip args->offset */ |
| /* skip args->indexType */ |
| } |
| |
| static inline void vn_decode_vkCmdBindVertexBuffers_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindVertexBuffers *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->firstBinding); |
| vn_decode_uint32_t(dec, &args->bindingCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->bindingCount); |
| args->pBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBuffers) * iter_count); |
| if (!args->pBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pBuffers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pBuffers = NULL; |
| } |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->bindingCount); |
| args->pOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pOffsets) * array_size); |
| if (!args->pOffsets) return; |
| vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pOffsets, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pOffsets = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdBindVertexBuffers_args_handle(struct vn_command_vkCmdBindVertexBuffers *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->firstBinding */ |
| /* skip args->bindingCount */ |
| if (args->pBuffers) { |
| for (uint32_t i = 0; i < args->bindingCount; i++) |
| vn_replace_VkBuffer_handle(&((VkBuffer *)args->pBuffers)[i]); |
| } |
| /* skip args->pOffsets */ |
| } |
| |
| static inline void vn_encode_vkCmdBindVertexBuffers_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindVertexBuffers *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->firstBinding */ |
| /* skip args->bindingCount */ |
| /* skip args->pBuffers */ |
| /* skip args->pOffsets */ |
| } |
| |
| static inline void vn_decode_vkCmdDraw_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDraw *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->vertexCount); |
| vn_decode_uint32_t(dec, &args->instanceCount); |
| vn_decode_uint32_t(dec, &args->firstVertex); |
| vn_decode_uint32_t(dec, &args->firstInstance); |
| } |
| |
| static inline void vn_replace_vkCmdDraw_args_handle(struct vn_command_vkCmdDraw *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->vertexCount */ |
| /* skip args->instanceCount */ |
| /* skip args->firstVertex */ |
| /* skip args->firstInstance */ |
| } |
| |
| static inline void vn_encode_vkCmdDraw_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDraw *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDraw_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->vertexCount */ |
| /* skip args->instanceCount */ |
| /* skip args->firstVertex */ |
| /* skip args->firstInstance */ |
| } |
| |
| static inline void vn_decode_vkCmdDrawIndexed_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndexed *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->indexCount); |
| vn_decode_uint32_t(dec, &args->instanceCount); |
| vn_decode_uint32_t(dec, &args->firstIndex); |
| vn_decode_int32_t(dec, &args->vertexOffset); |
| vn_decode_uint32_t(dec, &args->firstInstance); |
| } |
| |
| static inline void vn_replace_vkCmdDrawIndexed_args_handle(struct vn_command_vkCmdDrawIndexed *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->indexCount */ |
| /* skip args->instanceCount */ |
| /* skip args->firstIndex */ |
| /* skip args->vertexOffset */ |
| /* skip args->firstInstance */ |
| } |
| |
| static inline void vn_encode_vkCmdDrawIndexed_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndexed *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->indexCount */ |
| /* skip args->instanceCount */ |
| /* skip args->firstIndex */ |
| /* skip args->vertexOffset */ |
| /* skip args->firstInstance */ |
| } |
| |
| static inline void vn_decode_vkCmdDrawIndirect_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndirect *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->buffer); |
| vn_decode_VkDeviceSize(dec, &args->offset); |
| vn_decode_uint32_t(dec, &args->drawCount); |
| vn_decode_uint32_t(dec, &args->stride); |
| } |
| |
| static inline void vn_replace_vkCmdDrawIndirect_args_handle(struct vn_command_vkCmdDrawIndirect *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->buffer); |
| /* skip args->offset */ |
| /* skip args->drawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_encode_vkCmdDrawIndirect_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndirect *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->buffer */ |
| /* skip args->offset */ |
| /* skip args->drawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_decode_vkCmdDrawIndexedIndirect_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndexedIndirect *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->buffer); |
| vn_decode_VkDeviceSize(dec, &args->offset); |
| vn_decode_uint32_t(dec, &args->drawCount); |
| vn_decode_uint32_t(dec, &args->stride); |
| } |
| |
| static inline void vn_replace_vkCmdDrawIndexedIndirect_args_handle(struct vn_command_vkCmdDrawIndexedIndirect *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->buffer); |
| /* skip args->offset */ |
| /* skip args->drawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_encode_vkCmdDrawIndexedIndirect_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndexedIndirect *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->buffer */ |
| /* skip args->offset */ |
| /* skip args->drawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_decode_vkCmdDispatch_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDispatch *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->groupCountX); |
| vn_decode_uint32_t(dec, &args->groupCountY); |
| vn_decode_uint32_t(dec, &args->groupCountZ); |
| } |
| |
| static inline void vn_replace_vkCmdDispatch_args_handle(struct vn_command_vkCmdDispatch *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->groupCountX */ |
| /* skip args->groupCountY */ |
| /* skip args->groupCountZ */ |
| } |
| |
| static inline void vn_encode_vkCmdDispatch_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDispatch *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDispatch_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->groupCountX */ |
| /* skip args->groupCountY */ |
| /* skip args->groupCountZ */ |
| } |
| |
| static inline void vn_decode_vkCmdDispatchIndirect_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDispatchIndirect *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->buffer); |
| vn_decode_VkDeviceSize(dec, &args->offset); |
| } |
| |
| static inline void vn_replace_vkCmdDispatchIndirect_args_handle(struct vn_command_vkCmdDispatchIndirect *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->buffer); |
| /* skip args->offset */ |
| } |
| |
| static inline void vn_encode_vkCmdDispatchIndirect_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDispatchIndirect *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->buffer */ |
| /* skip args->offset */ |
| } |
| |
| static inline void vn_decode_vkCmdCopyBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->srcBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->dstBuffer); |
| vn_decode_uint32_t(dec, &args->regionCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount); |
| args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count); |
| if (!args->pRegions) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBufferCopy_temp(dec, &((VkBufferCopy *)args->pRegions)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRegions = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdCopyBuffer_args_handle(struct vn_command_vkCmdCopyBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->srcBuffer); |
| vn_replace_VkBuffer_handle(&args->dstBuffer); |
| /* skip args->regionCount */ |
| if (args->pRegions) { |
| for (uint32_t i = 0; i < args->regionCount; i++) |
| vn_replace_VkBufferCopy_handle(&((VkBufferCopy *)args->pRegions)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdCopyBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcBuffer */ |
| /* skip args->dstBuffer */ |
| /* skip args->regionCount */ |
| /* skip args->pRegions */ |
| } |
| |
| static inline void vn_decode_vkCmdCopyImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyImage *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkImage_lookup(dec, &args->srcImage); |
| vn_decode_VkImageLayout(dec, &args->srcImageLayout); |
| vn_decode_VkImage_lookup(dec, &args->dstImage); |
| vn_decode_VkImageLayout(dec, &args->dstImageLayout); |
| vn_decode_uint32_t(dec, &args->regionCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount); |
| args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count); |
| if (!args->pRegions) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageCopy_temp(dec, &((VkImageCopy *)args->pRegions)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRegions = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdCopyImage_args_handle(struct vn_command_vkCmdCopyImage *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkImage_handle(&args->srcImage); |
| /* skip args->srcImageLayout */ |
| vn_replace_VkImage_handle(&args->dstImage); |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| if (args->pRegions) { |
| for (uint32_t i = 0; i < args->regionCount; i++) |
| vn_replace_VkImageCopy_handle(&((VkImageCopy *)args->pRegions)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdCopyImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyImage *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyImage_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcImage */ |
| /* skip args->srcImageLayout */ |
| /* skip args->dstImage */ |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| /* skip args->pRegions */ |
| } |
| |
| static inline void vn_decode_vkCmdBlitImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBlitImage *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkImage_lookup(dec, &args->srcImage); |
| vn_decode_VkImageLayout(dec, &args->srcImageLayout); |
| vn_decode_VkImage_lookup(dec, &args->dstImage); |
| vn_decode_VkImageLayout(dec, &args->dstImageLayout); |
| vn_decode_uint32_t(dec, &args->regionCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount); |
| args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count); |
| if (!args->pRegions) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageBlit_temp(dec, &((VkImageBlit *)args->pRegions)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRegions = NULL; |
| } |
| vn_decode_VkFilter(dec, &args->filter); |
| } |
| |
| static inline void vn_replace_vkCmdBlitImage_args_handle(struct vn_command_vkCmdBlitImage *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkImage_handle(&args->srcImage); |
| /* skip args->srcImageLayout */ |
| vn_replace_VkImage_handle(&args->dstImage); |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| if (args->pRegions) { |
| for (uint32_t i = 0; i < args->regionCount; i++) |
| vn_replace_VkImageBlit_handle(&((VkImageBlit *)args->pRegions)[i]); |
| } |
| /* skip args->filter */ |
| } |
| |
| static inline void vn_encode_vkCmdBlitImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBlitImage *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBlitImage_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcImage */ |
| /* skip args->srcImageLayout */ |
| /* skip args->dstImage */ |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| /* skip args->pRegions */ |
| /* skip args->filter */ |
| } |
| |
| static inline void vn_decode_vkCmdCopyBufferToImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyBufferToImage *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->srcBuffer); |
| vn_decode_VkImage_lookup(dec, &args->dstImage); |
| vn_decode_VkImageLayout(dec, &args->dstImageLayout); |
| vn_decode_uint32_t(dec, &args->regionCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount); |
| args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count); |
| if (!args->pRegions) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBufferImageCopy_temp(dec, &((VkBufferImageCopy *)args->pRegions)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRegions = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdCopyBufferToImage_args_handle(struct vn_command_vkCmdCopyBufferToImage *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->srcBuffer); |
| vn_replace_VkImage_handle(&args->dstImage); |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| if (args->pRegions) { |
| for (uint32_t i = 0; i < args->regionCount; i++) |
| vn_replace_VkBufferImageCopy_handle(&((VkBufferImageCopy *)args->pRegions)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdCopyBufferToImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyBufferToImage *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcBuffer */ |
| /* skip args->dstImage */ |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| /* skip args->pRegions */ |
| } |
| |
| static inline void vn_decode_vkCmdCopyImageToBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyImageToBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkImage_lookup(dec, &args->srcImage); |
| vn_decode_VkImageLayout(dec, &args->srcImageLayout); |
| vn_decode_VkBuffer_lookup(dec, &args->dstBuffer); |
| vn_decode_uint32_t(dec, &args->regionCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount); |
| args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count); |
| if (!args->pRegions) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBufferImageCopy_temp(dec, &((VkBufferImageCopy *)args->pRegions)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRegions = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdCopyImageToBuffer_args_handle(struct vn_command_vkCmdCopyImageToBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkImage_handle(&args->srcImage); |
| /* skip args->srcImageLayout */ |
| vn_replace_VkBuffer_handle(&args->dstBuffer); |
| /* skip args->regionCount */ |
| if (args->pRegions) { |
| for (uint32_t i = 0; i < args->regionCount; i++) |
| vn_replace_VkBufferImageCopy_handle(&((VkBufferImageCopy *)args->pRegions)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdCopyImageToBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyImageToBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcImage */ |
| /* skip args->srcImageLayout */ |
| /* skip args->dstBuffer */ |
| /* skip args->regionCount */ |
| /* skip args->pRegions */ |
| } |
| |
| static inline void vn_decode_vkCmdUpdateBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdUpdateBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->dstBuffer); |
| vn_decode_VkDeviceSize(dec, &args->dstOffset); |
| vn_decode_VkDeviceSize(dec, &args->dataSize); |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->dataSize); |
| args->pData = vn_cs_decoder_alloc_temp(dec, array_size); |
| if (!args->pData) return; |
| vn_decode_blob_array(dec, (void *)args->pData, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pData = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdUpdateBuffer_args_handle(struct vn_command_vkCmdUpdateBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->dstBuffer); |
| /* skip args->dstOffset */ |
| /* skip args->dataSize */ |
| /* skip args->pData */ |
| } |
| |
| static inline void vn_encode_vkCmdUpdateBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdUpdateBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->dstBuffer */ |
| /* skip args->dstOffset */ |
| /* skip args->dataSize */ |
| /* skip args->pData */ |
| } |
| |
| static inline void vn_decode_vkCmdFillBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdFillBuffer *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->dstBuffer); |
| vn_decode_VkDeviceSize(dec, &args->dstOffset); |
| vn_decode_VkDeviceSize(dec, &args->size); |
| vn_decode_uint32_t(dec, &args->data); |
| } |
| |
| static inline void vn_replace_vkCmdFillBuffer_args_handle(struct vn_command_vkCmdFillBuffer *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->dstBuffer); |
| /* skip args->dstOffset */ |
| /* skip args->size */ |
| /* skip args->data */ |
| } |
| |
| static inline void vn_encode_vkCmdFillBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdFillBuffer *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdFillBuffer_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->dstBuffer */ |
| /* skip args->dstOffset */ |
| /* skip args->size */ |
| /* skip args->data */ |
| } |
| |
| static inline void vn_decode_vkCmdClearColorImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdClearColorImage *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkImage_lookup(dec, &args->image); |
| vn_decode_VkImageLayout(dec, &args->imageLayout); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pColor = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pColor)); |
| if (!args->pColor) return; |
| vn_decode_VkClearColorValue_temp(dec, (VkClearColorValue *)args->pColor); |
| } else { |
| args->pColor = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->rangeCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->rangeCount); |
| args->pRanges = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRanges) * iter_count); |
| if (!args->pRanges) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageSubresourceRange_temp(dec, &((VkImageSubresourceRange *)args->pRanges)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRanges = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdClearColorImage_args_handle(struct vn_command_vkCmdClearColorImage *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkImage_handle(&args->image); |
| /* skip args->imageLayout */ |
| /* skip args->pColor */ |
| /* skip args->rangeCount */ |
| if (args->pRanges) { |
| for (uint32_t i = 0; i < args->rangeCount; i++) |
| vn_replace_VkImageSubresourceRange_handle(&((VkImageSubresourceRange *)args->pRanges)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdClearColorImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdClearColorImage *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdClearColorImage_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->image */ |
| /* skip args->imageLayout */ |
| /* skip args->pColor */ |
| /* skip args->rangeCount */ |
| /* skip args->pRanges */ |
| } |
| |
| static inline void vn_decode_vkCmdClearDepthStencilImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdClearDepthStencilImage *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkImage_lookup(dec, &args->image); |
| vn_decode_VkImageLayout(dec, &args->imageLayout); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pDepthStencil = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDepthStencil)); |
| if (!args->pDepthStencil) return; |
| vn_decode_VkClearDepthStencilValue_temp(dec, (VkClearDepthStencilValue *)args->pDepthStencil); |
| } else { |
| args->pDepthStencil = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| vn_decode_uint32_t(dec, &args->rangeCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->rangeCount); |
| args->pRanges = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRanges) * iter_count); |
| if (!args->pRanges) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageSubresourceRange_temp(dec, &((VkImageSubresourceRange *)args->pRanges)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRanges = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdClearDepthStencilImage_args_handle(struct vn_command_vkCmdClearDepthStencilImage *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkImage_handle(&args->image); |
| /* skip args->imageLayout */ |
| if (args->pDepthStencil) |
| vn_replace_VkClearDepthStencilValue_handle((VkClearDepthStencilValue *)args->pDepthStencil); |
| /* skip args->rangeCount */ |
| if (args->pRanges) { |
| for (uint32_t i = 0; i < args->rangeCount; i++) |
| vn_replace_VkImageSubresourceRange_handle(&((VkImageSubresourceRange *)args->pRanges)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdClearDepthStencilImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdClearDepthStencilImage *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->image */ |
| /* skip args->imageLayout */ |
| /* skip args->pDepthStencil */ |
| /* skip args->rangeCount */ |
| /* skip args->pRanges */ |
| } |
| |
| static inline void vn_decode_vkCmdClearAttachments_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdClearAttachments *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->attachmentCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->attachmentCount); |
| args->pAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pAttachments) * iter_count); |
| if (!args->pAttachments) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkClearAttachment_temp(dec, &((VkClearAttachment *)args->pAttachments)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pAttachments = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->rectCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->rectCount); |
| args->pRects = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRects) * iter_count); |
| if (!args->pRects) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkClearRect_temp(dec, &((VkClearRect *)args->pRects)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRects = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdClearAttachments_args_handle(struct vn_command_vkCmdClearAttachments *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->attachmentCount */ |
| if (args->pAttachments) { |
| for (uint32_t i = 0; i < args->attachmentCount; i++) |
| vn_replace_VkClearAttachment_handle(&((VkClearAttachment *)args->pAttachments)[i]); |
| } |
| /* skip args->rectCount */ |
| if (args->pRects) { |
| for (uint32_t i = 0; i < args->rectCount; i++) |
| vn_replace_VkClearRect_handle(&((VkClearRect *)args->pRects)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdClearAttachments_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdClearAttachments *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdClearAttachments_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->attachmentCount */ |
| /* skip args->pAttachments */ |
| /* skip args->rectCount */ |
| /* skip args->pRects */ |
| } |
| |
| static inline void vn_decode_vkCmdResolveImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResolveImage *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkImage_lookup(dec, &args->srcImage); |
| vn_decode_VkImageLayout(dec, &args->srcImageLayout); |
| vn_decode_VkImage_lookup(dec, &args->dstImage); |
| vn_decode_VkImageLayout(dec, &args->dstImageLayout); |
| vn_decode_uint32_t(dec, &args->regionCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount); |
| args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count); |
| if (!args->pRegions) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageResolve_temp(dec, &((VkImageResolve *)args->pRegions)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pRegions = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdResolveImage_args_handle(struct vn_command_vkCmdResolveImage *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkImage_handle(&args->srcImage); |
| /* skip args->srcImageLayout */ |
| vn_replace_VkImage_handle(&args->dstImage); |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| if (args->pRegions) { |
| for (uint32_t i = 0; i < args->regionCount; i++) |
| vn_replace_VkImageResolve_handle(&((VkImageResolve *)args->pRegions)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdResolveImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResolveImage *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResolveImage_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcImage */ |
| /* skip args->srcImageLayout */ |
| /* skip args->dstImage */ |
| /* skip args->dstImageLayout */ |
| /* skip args->regionCount */ |
| /* skip args->pRegions */ |
| } |
| |
| static inline void vn_decode_vkCmdSetEvent_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetEvent *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkEvent_lookup(dec, &args->event); |
| vn_decode_VkFlags(dec, &args->stageMask); |
| } |
| |
| static inline void vn_replace_vkCmdSetEvent_args_handle(struct vn_command_vkCmdSetEvent *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkEvent_handle(&args->event); |
| /* skip args->stageMask */ |
| } |
| |
| static inline void vn_encode_vkCmdSetEvent_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetEvent *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetEvent_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->event */ |
| /* skip args->stageMask */ |
| } |
| |
| static inline void vn_decode_vkCmdResetEvent_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResetEvent *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkEvent_lookup(dec, &args->event); |
| vn_decode_VkFlags(dec, &args->stageMask); |
| } |
| |
| static inline void vn_replace_vkCmdResetEvent_args_handle(struct vn_command_vkCmdResetEvent *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkEvent_handle(&args->event); |
| /* skip args->stageMask */ |
| } |
| |
| static inline void vn_encode_vkCmdResetEvent_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResetEvent *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResetEvent_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->event */ |
| /* skip args->stageMask */ |
| } |
| |
| static inline void vn_decode_vkCmdWaitEvents_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdWaitEvents *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->eventCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->eventCount); |
| args->pEvents = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pEvents) * iter_count); |
| if (!args->pEvents) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkEvent_lookup(dec, &((VkEvent *)args->pEvents)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pEvents = NULL; |
| } |
| vn_decode_VkFlags(dec, &args->srcStageMask); |
| vn_decode_VkFlags(dec, &args->dstStageMask); |
| vn_decode_uint32_t(dec, &args->memoryBarrierCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->memoryBarrierCount); |
| args->pMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryBarriers) * iter_count); |
| if (!args->pMemoryBarriers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkMemoryBarrier_temp(dec, &((VkMemoryBarrier *)args->pMemoryBarriers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pMemoryBarriers = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->bufferMemoryBarrierCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->bufferMemoryBarrierCount); |
| args->pBufferMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBufferMemoryBarriers) * iter_count); |
| if (!args->pBufferMemoryBarriers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBufferMemoryBarrier_temp(dec, &((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pBufferMemoryBarriers = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->imageMemoryBarrierCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->imageMemoryBarrierCount); |
| args->pImageMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageMemoryBarriers) * iter_count); |
| if (!args->pImageMemoryBarriers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageMemoryBarrier_temp(dec, &((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pImageMemoryBarriers = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdWaitEvents_args_handle(struct vn_command_vkCmdWaitEvents *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->eventCount */ |
| if (args->pEvents) { |
| for (uint32_t i = 0; i < args->eventCount; i++) |
| vn_replace_VkEvent_handle(&((VkEvent *)args->pEvents)[i]); |
| } |
| /* skip args->srcStageMask */ |
| /* skip args->dstStageMask */ |
| /* skip args->memoryBarrierCount */ |
| if (args->pMemoryBarriers) { |
| for (uint32_t i = 0; i < args->memoryBarrierCount; i++) |
| vn_replace_VkMemoryBarrier_handle(&((VkMemoryBarrier *)args->pMemoryBarriers)[i]); |
| } |
| /* skip args->bufferMemoryBarrierCount */ |
| if (args->pBufferMemoryBarriers) { |
| for (uint32_t i = 0; i < args->bufferMemoryBarrierCount; i++) |
| vn_replace_VkBufferMemoryBarrier_handle(&((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]); |
| } |
| /* skip args->imageMemoryBarrierCount */ |
| if (args->pImageMemoryBarriers) { |
| for (uint32_t i = 0; i < args->imageMemoryBarrierCount; i++) |
| vn_replace_VkImageMemoryBarrier_handle(&((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdWaitEvents_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdWaitEvents *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdWaitEvents_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->eventCount */ |
| /* skip args->pEvents */ |
| /* skip args->srcStageMask */ |
| /* skip args->dstStageMask */ |
| /* skip args->memoryBarrierCount */ |
| /* skip args->pMemoryBarriers */ |
| /* skip args->bufferMemoryBarrierCount */ |
| /* skip args->pBufferMemoryBarriers */ |
| /* skip args->imageMemoryBarrierCount */ |
| /* skip args->pImageMemoryBarriers */ |
| } |
| |
| static inline void vn_decode_vkCmdPipelineBarrier_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdPipelineBarrier *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkFlags(dec, &args->srcStageMask); |
| vn_decode_VkFlags(dec, &args->dstStageMask); |
| vn_decode_VkFlags(dec, &args->dependencyFlags); |
| vn_decode_uint32_t(dec, &args->memoryBarrierCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->memoryBarrierCount); |
| args->pMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryBarriers) * iter_count); |
| if (!args->pMemoryBarriers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkMemoryBarrier_temp(dec, &((VkMemoryBarrier *)args->pMemoryBarriers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pMemoryBarriers = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->bufferMemoryBarrierCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->bufferMemoryBarrierCount); |
| args->pBufferMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBufferMemoryBarriers) * iter_count); |
| if (!args->pBufferMemoryBarriers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBufferMemoryBarrier_temp(dec, &((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pBufferMemoryBarriers = NULL; |
| } |
| vn_decode_uint32_t(dec, &args->imageMemoryBarrierCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->imageMemoryBarrierCount); |
| args->pImageMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageMemoryBarriers) * iter_count); |
| if (!args->pImageMemoryBarriers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkImageMemoryBarrier_temp(dec, &((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pImageMemoryBarriers = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdPipelineBarrier_args_handle(struct vn_command_vkCmdPipelineBarrier *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->srcStageMask */ |
| /* skip args->dstStageMask */ |
| /* skip args->dependencyFlags */ |
| /* skip args->memoryBarrierCount */ |
| if (args->pMemoryBarriers) { |
| for (uint32_t i = 0; i < args->memoryBarrierCount; i++) |
| vn_replace_VkMemoryBarrier_handle(&((VkMemoryBarrier *)args->pMemoryBarriers)[i]); |
| } |
| /* skip args->bufferMemoryBarrierCount */ |
| if (args->pBufferMemoryBarriers) { |
| for (uint32_t i = 0; i < args->bufferMemoryBarrierCount; i++) |
| vn_replace_VkBufferMemoryBarrier_handle(&((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]); |
| } |
| /* skip args->imageMemoryBarrierCount */ |
| if (args->pImageMemoryBarriers) { |
| for (uint32_t i = 0; i < args->imageMemoryBarrierCount; i++) |
| vn_replace_VkImageMemoryBarrier_handle(&((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdPipelineBarrier_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdPipelineBarrier *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->srcStageMask */ |
| /* skip args->dstStageMask */ |
| /* skip args->dependencyFlags */ |
| /* skip args->memoryBarrierCount */ |
| /* skip args->pMemoryBarriers */ |
| /* skip args->bufferMemoryBarrierCount */ |
| /* skip args->pBufferMemoryBarriers */ |
| /* skip args->imageMemoryBarrierCount */ |
| /* skip args->pImageMemoryBarriers */ |
| } |
| |
| static inline void vn_decode_vkCmdBeginQuery_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginQuery *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->query); |
| vn_decode_VkFlags(dec, &args->flags); |
| } |
| |
| static inline void vn_replace_vkCmdBeginQuery_args_handle(struct vn_command_vkCmdBeginQuery *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->query */ |
| /* skip args->flags */ |
| } |
| |
| static inline void vn_encode_vkCmdBeginQuery_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginQuery *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginQuery_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->queryPool */ |
| /* skip args->query */ |
| /* skip args->flags */ |
| } |
| |
| static inline void vn_decode_vkCmdEndQuery_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndQuery *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->query); |
| } |
| |
| static inline void vn_replace_vkCmdEndQuery_args_handle(struct vn_command_vkCmdEndQuery *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->query */ |
| } |
| |
| static inline void vn_encode_vkCmdEndQuery_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndQuery *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndQuery_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->queryPool */ |
| /* skip args->query */ |
| } |
| |
| static inline void vn_decode_vkCmdResetQueryPool_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResetQueryPool *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->firstQuery); |
| vn_decode_uint32_t(dec, &args->queryCount); |
| } |
| |
| static inline void vn_replace_vkCmdResetQueryPool_args_handle(struct vn_command_vkCmdResetQueryPool *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->firstQuery */ |
| /* skip args->queryCount */ |
| } |
| |
| static inline void vn_encode_vkCmdResetQueryPool_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResetQueryPool *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->queryPool */ |
| /* skip args->firstQuery */ |
| /* skip args->queryCount */ |
| } |
| |
| static inline void vn_decode_vkCmdWriteTimestamp_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdWriteTimestamp *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkPipelineStageFlagBits(dec, &args->pipelineStage); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->query); |
| } |
| |
| static inline void vn_replace_vkCmdWriteTimestamp_args_handle(struct vn_command_vkCmdWriteTimestamp *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->pipelineStage */ |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->query */ |
| } |
| |
| static inline void vn_encode_vkCmdWriteTimestamp_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdWriteTimestamp *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pipelineStage */ |
| /* skip args->queryPool */ |
| /* skip args->query */ |
| } |
| |
| static inline void vn_decode_vkCmdCopyQueryPoolResults_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyQueryPoolResults *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->firstQuery); |
| vn_decode_uint32_t(dec, &args->queryCount); |
| vn_decode_VkBuffer_lookup(dec, &args->dstBuffer); |
| vn_decode_VkDeviceSize(dec, &args->dstOffset); |
| vn_decode_VkDeviceSize(dec, &args->stride); |
| vn_decode_VkFlags(dec, &args->flags); |
| } |
| |
| static inline void vn_replace_vkCmdCopyQueryPoolResults_args_handle(struct vn_command_vkCmdCopyQueryPoolResults *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->firstQuery */ |
| /* skip args->queryCount */ |
| vn_replace_VkBuffer_handle(&args->dstBuffer); |
| /* skip args->dstOffset */ |
| /* skip args->stride */ |
| /* skip args->flags */ |
| } |
| |
| static inline void vn_encode_vkCmdCopyQueryPoolResults_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyQueryPoolResults *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->queryPool */ |
| /* skip args->firstQuery */ |
| /* skip args->queryCount */ |
| /* skip args->dstBuffer */ |
| /* skip args->dstOffset */ |
| /* skip args->stride */ |
| /* skip args->flags */ |
| } |
| |
| static inline void vn_decode_vkCmdPushConstants_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdPushConstants *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkPipelineLayout_lookup(dec, &args->layout); |
| vn_decode_VkFlags(dec, &args->stageFlags); |
| vn_decode_uint32_t(dec, &args->offset); |
| vn_decode_uint32_t(dec, &args->size); |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->size); |
| args->pValues = vn_cs_decoder_alloc_temp(dec, array_size); |
| if (!args->pValues) return; |
| vn_decode_blob_array(dec, (void *)args->pValues, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pValues = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdPushConstants_args_handle(struct vn_command_vkCmdPushConstants *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkPipelineLayout_handle(&args->layout); |
| /* skip args->stageFlags */ |
| /* skip args->offset */ |
| /* skip args->size */ |
| /* skip args->pValues */ |
| } |
| |
| static inline void vn_encode_vkCmdPushConstants_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdPushConstants *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdPushConstants_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->layout */ |
| /* skip args->stageFlags */ |
| /* skip args->offset */ |
| /* skip args->size */ |
| /* skip args->pValues */ |
| } |
| |
| static inline void vn_decode_vkCmdBeginRenderPass_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginRenderPass *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pRenderPassBegin = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRenderPassBegin)); |
| if (!args->pRenderPassBegin) return; |
| vn_decode_VkRenderPassBeginInfo_temp(dec, (VkRenderPassBeginInfo *)args->pRenderPassBegin); |
| } else { |
| args->pRenderPassBegin = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| vn_decode_VkSubpassContents(dec, &args->contents); |
| } |
| |
| static inline void vn_replace_vkCmdBeginRenderPass_args_handle(struct vn_command_vkCmdBeginRenderPass *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| if (args->pRenderPassBegin) |
| vn_replace_VkRenderPassBeginInfo_handle((VkRenderPassBeginInfo *)args->pRenderPassBegin); |
| /* skip args->contents */ |
| } |
| |
| static inline void vn_encode_vkCmdBeginRenderPass_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginRenderPass *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pRenderPassBegin */ |
| /* skip args->contents */ |
| } |
| |
| static inline void vn_decode_vkCmdNextSubpass_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdNextSubpass *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkSubpassContents(dec, &args->contents); |
| } |
| |
| static inline void vn_replace_vkCmdNextSubpass_args_handle(struct vn_command_vkCmdNextSubpass *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->contents */ |
| } |
| |
| static inline void vn_encode_vkCmdNextSubpass_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdNextSubpass *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdNextSubpass_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->contents */ |
| } |
| |
| static inline void vn_decode_vkCmdEndRenderPass_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndRenderPass *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| } |
| |
| static inline void vn_replace_vkCmdEndRenderPass_args_handle(struct vn_command_vkCmdEndRenderPass *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| } |
| |
| static inline void vn_encode_vkCmdEndRenderPass_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndRenderPass *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT}); |
| |
| /* skip args->commandBuffer */ |
| } |
| |
| static inline void vn_decode_vkCmdExecuteCommands_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdExecuteCommands *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->commandBufferCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->commandBufferCount); |
| args->pCommandBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCommandBuffers) * iter_count); |
| if (!args->pCommandBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkCommandBuffer_lookup(dec, &((VkCommandBuffer *)args->pCommandBuffers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCommandBuffers = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdExecuteCommands_args_handle(struct vn_command_vkCmdExecuteCommands *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->commandBufferCount */ |
| if (args->pCommandBuffers) { |
| for (uint32_t i = 0; i < args->commandBufferCount; i++) |
| vn_replace_VkCommandBuffer_handle(&((VkCommandBuffer *)args->pCommandBuffers)[i]); |
| } |
| } |
| |
| static inline void vn_encode_vkCmdExecuteCommands_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdExecuteCommands *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->commandBufferCount */ |
| /* skip args->pCommandBuffers */ |
| } |
| |
| static inline void vn_decode_vkCmdSetDeviceMask_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDeviceMask *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->deviceMask); |
| } |
| |
| static inline void vn_replace_vkCmdSetDeviceMask_args_handle(struct vn_command_vkCmdSetDeviceMask *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->deviceMask */ |
| } |
| |
| static inline void vn_encode_vkCmdSetDeviceMask_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDeviceMask *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->deviceMask */ |
| } |
| |
| static inline void vn_decode_vkCmdDispatchBase_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDispatchBase *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->baseGroupX); |
| vn_decode_uint32_t(dec, &args->baseGroupY); |
| vn_decode_uint32_t(dec, &args->baseGroupZ); |
| vn_decode_uint32_t(dec, &args->groupCountX); |
| vn_decode_uint32_t(dec, &args->groupCountY); |
| vn_decode_uint32_t(dec, &args->groupCountZ); |
| } |
| |
| static inline void vn_replace_vkCmdDispatchBase_args_handle(struct vn_command_vkCmdDispatchBase *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->baseGroupX */ |
| /* skip args->baseGroupY */ |
| /* skip args->baseGroupZ */ |
| /* skip args->groupCountX */ |
| /* skip args->groupCountY */ |
| /* skip args->groupCountZ */ |
| } |
| |
| static inline void vn_encode_vkCmdDispatchBase_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDispatchBase *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDispatchBase_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->baseGroupX */ |
| /* skip args->baseGroupY */ |
| /* skip args->baseGroupZ */ |
| /* skip args->groupCountX */ |
| /* skip args->groupCountY */ |
| /* skip args->groupCountZ */ |
| } |
| |
| static inline void vn_decode_vkCmdBeginRenderPass2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginRenderPass2 *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pRenderPassBegin = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRenderPassBegin)); |
| if (!args->pRenderPassBegin) return; |
| vn_decode_VkRenderPassBeginInfo_temp(dec, (VkRenderPassBeginInfo *)args->pRenderPassBegin); |
| } else { |
| args->pRenderPassBegin = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| if (vn_decode_simple_pointer(dec)) { |
| args->pSubpassBeginInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassBeginInfo)); |
| if (!args->pSubpassBeginInfo) return; |
| vn_decode_VkSubpassBeginInfo_temp(dec, (VkSubpassBeginInfo *)args->pSubpassBeginInfo); |
| } else { |
| args->pSubpassBeginInfo = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| } |
| |
| static inline void vn_replace_vkCmdBeginRenderPass2_args_handle(struct vn_command_vkCmdBeginRenderPass2 *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| if (args->pRenderPassBegin) |
| vn_replace_VkRenderPassBeginInfo_handle((VkRenderPassBeginInfo *)args->pRenderPassBegin); |
| if (args->pSubpassBeginInfo) |
| vn_replace_VkSubpassBeginInfo_handle((VkSubpassBeginInfo *)args->pSubpassBeginInfo); |
| } |
| |
| static inline void vn_encode_vkCmdBeginRenderPass2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginRenderPass2 *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pRenderPassBegin */ |
| /* skip args->pSubpassBeginInfo */ |
| } |
| |
| static inline void vn_decode_vkCmdNextSubpass2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdNextSubpass2 *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pSubpassBeginInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassBeginInfo)); |
| if (!args->pSubpassBeginInfo) return; |
| vn_decode_VkSubpassBeginInfo_temp(dec, (VkSubpassBeginInfo *)args->pSubpassBeginInfo); |
| } else { |
| args->pSubpassBeginInfo = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| if (vn_decode_simple_pointer(dec)) { |
| args->pSubpassEndInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassEndInfo)); |
| if (!args->pSubpassEndInfo) return; |
| vn_decode_VkSubpassEndInfo_temp(dec, (VkSubpassEndInfo *)args->pSubpassEndInfo); |
| } else { |
| args->pSubpassEndInfo = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| } |
| |
| static inline void vn_replace_vkCmdNextSubpass2_args_handle(struct vn_command_vkCmdNextSubpass2 *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| if (args->pSubpassBeginInfo) |
| vn_replace_VkSubpassBeginInfo_handle((VkSubpassBeginInfo *)args->pSubpassBeginInfo); |
| if (args->pSubpassEndInfo) |
| vn_replace_VkSubpassEndInfo_handle((VkSubpassEndInfo *)args->pSubpassEndInfo); |
| } |
| |
| static inline void vn_encode_vkCmdNextSubpass2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdNextSubpass2 *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pSubpassBeginInfo */ |
| /* skip args->pSubpassEndInfo */ |
| } |
| |
| static inline void vn_decode_vkCmdEndRenderPass2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndRenderPass2 *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| if (vn_decode_simple_pointer(dec)) { |
| args->pSubpassEndInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassEndInfo)); |
| if (!args->pSubpassEndInfo) return; |
| vn_decode_VkSubpassEndInfo_temp(dec, (VkSubpassEndInfo *)args->pSubpassEndInfo); |
| } else { |
| args->pSubpassEndInfo = NULL; |
| vn_cs_decoder_set_fatal(dec); |
| } |
| } |
| |
| static inline void vn_replace_vkCmdEndRenderPass2_args_handle(struct vn_command_vkCmdEndRenderPass2 *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| if (args->pSubpassEndInfo) |
| vn_replace_VkSubpassEndInfo_handle((VkSubpassEndInfo *)args->pSubpassEndInfo); |
| } |
| |
| static inline void vn_encode_vkCmdEndRenderPass2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndRenderPass2 *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->pSubpassEndInfo */ |
| } |
| |
| static inline void vn_decode_vkCmdDrawIndirectCount_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndirectCount *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->buffer); |
| vn_decode_VkDeviceSize(dec, &args->offset); |
| vn_decode_VkBuffer_lookup(dec, &args->countBuffer); |
| vn_decode_VkDeviceSize(dec, &args->countBufferOffset); |
| vn_decode_uint32_t(dec, &args->maxDrawCount); |
| vn_decode_uint32_t(dec, &args->stride); |
| } |
| |
| static inline void vn_replace_vkCmdDrawIndirectCount_args_handle(struct vn_command_vkCmdDrawIndirectCount *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->buffer); |
| /* skip args->offset */ |
| vn_replace_VkBuffer_handle(&args->countBuffer); |
| /* skip args->countBufferOffset */ |
| /* skip args->maxDrawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_encode_vkCmdDrawIndirectCount_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndirectCount *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->buffer */ |
| /* skip args->offset */ |
| /* skip args->countBuffer */ |
| /* skip args->countBufferOffset */ |
| /* skip args->maxDrawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_decode_vkCmdDrawIndexedIndirectCount_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndexedIndirectCount *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkBuffer_lookup(dec, &args->buffer); |
| vn_decode_VkDeviceSize(dec, &args->offset); |
| vn_decode_VkBuffer_lookup(dec, &args->countBuffer); |
| vn_decode_VkDeviceSize(dec, &args->countBufferOffset); |
| vn_decode_uint32_t(dec, &args->maxDrawCount); |
| vn_decode_uint32_t(dec, &args->stride); |
| } |
| |
| static inline void vn_replace_vkCmdDrawIndexedIndirectCount_args_handle(struct vn_command_vkCmdDrawIndexedIndirectCount *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkBuffer_handle(&args->buffer); |
| /* skip args->offset */ |
| vn_replace_VkBuffer_handle(&args->countBuffer); |
| /* skip args->countBufferOffset */ |
| /* skip args->maxDrawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_encode_vkCmdDrawIndexedIndirectCount_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndexedIndirectCount *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->buffer */ |
| /* skip args->offset */ |
| /* skip args->countBuffer */ |
| /* skip args->countBufferOffset */ |
| /* skip args->maxDrawCount */ |
| /* skip args->stride */ |
| } |
| |
| static inline void vn_decode_vkCmdBindTransformFeedbackBuffersEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindTransformFeedbackBuffersEXT *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->firstBinding); |
| vn_decode_uint32_t(dec, &args->bindingCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->bindingCount); |
| args->pBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBuffers) * iter_count); |
| if (!args->pBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pBuffers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pBuffers = NULL; |
| } |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->bindingCount); |
| args->pOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pOffsets) * array_size); |
| if (!args->pOffsets) return; |
| vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pOffsets, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pOffsets = NULL; |
| } |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->bindingCount); |
| args->pSizes = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSizes) * array_size); |
| if (!args->pSizes) return; |
| vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pSizes, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pSizes = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdBindTransformFeedbackBuffersEXT_args_handle(struct vn_command_vkCmdBindTransformFeedbackBuffersEXT *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->firstBinding */ |
| /* skip args->bindingCount */ |
| if (args->pBuffers) { |
| for (uint32_t i = 0; i < args->bindingCount; i++) |
| vn_replace_VkBuffer_handle(&((VkBuffer *)args->pBuffers)[i]); |
| } |
| /* skip args->pOffsets */ |
| /* skip args->pSizes */ |
| } |
| |
| static inline void vn_encode_vkCmdBindTransformFeedbackBuffersEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindTransformFeedbackBuffersEXT *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->firstBinding */ |
| /* skip args->bindingCount */ |
| /* skip args->pBuffers */ |
| /* skip args->pOffsets */ |
| /* skip args->pSizes */ |
| } |
| |
| static inline void vn_decode_vkCmdBeginTransformFeedbackEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginTransformFeedbackEXT *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->firstCounterBuffer); |
| vn_decode_uint32_t(dec, &args->counterBufferCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->counterBufferCount); |
| args->pCounterBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBuffers) * iter_count); |
| if (!args->pCounterBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pCounterBuffers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCounterBuffers = NULL; |
| } |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->counterBufferCount); |
| args->pCounterBufferOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBufferOffsets) * array_size); |
| if (!args->pCounterBufferOffsets) return; |
| vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pCounterBufferOffsets, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCounterBufferOffsets = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdBeginTransformFeedbackEXT_args_handle(struct vn_command_vkCmdBeginTransformFeedbackEXT *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->firstCounterBuffer */ |
| /* skip args->counterBufferCount */ |
| if (args->pCounterBuffers) { |
| for (uint32_t i = 0; i < args->counterBufferCount; i++) |
| vn_replace_VkBuffer_handle(&((VkBuffer *)args->pCounterBuffers)[i]); |
| } |
| /* skip args->pCounterBufferOffsets */ |
| } |
| |
| static inline void vn_encode_vkCmdBeginTransformFeedbackEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginTransformFeedbackEXT *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->firstCounterBuffer */ |
| /* skip args->counterBufferCount */ |
| /* skip args->pCounterBuffers */ |
| /* skip args->pCounterBufferOffsets */ |
| } |
| |
| static inline void vn_decode_vkCmdEndTransformFeedbackEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndTransformFeedbackEXT *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->firstCounterBuffer); |
| vn_decode_uint32_t(dec, &args->counterBufferCount); |
| if (vn_peek_array_size(dec)) { |
| const uint32_t iter_count = vn_decode_array_size(dec, args->counterBufferCount); |
| args->pCounterBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBuffers) * iter_count); |
| if (!args->pCounterBuffers) return; |
| for (uint32_t i = 0; i < iter_count; i++) |
| vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pCounterBuffers)[i]); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCounterBuffers = NULL; |
| } |
| if (vn_peek_array_size(dec)) { |
| const size_t array_size = vn_decode_array_size(dec, args->counterBufferCount); |
| args->pCounterBufferOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBufferOffsets) * array_size); |
| if (!args->pCounterBufferOffsets) return; |
| vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pCounterBufferOffsets, array_size); |
| } else { |
| vn_decode_array_size(dec, 0); |
| args->pCounterBufferOffsets = NULL; |
| } |
| } |
| |
| static inline void vn_replace_vkCmdEndTransformFeedbackEXT_args_handle(struct vn_command_vkCmdEndTransformFeedbackEXT *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->firstCounterBuffer */ |
| /* skip args->counterBufferCount */ |
| if (args->pCounterBuffers) { |
| for (uint32_t i = 0; i < args->counterBufferCount; i++) |
| vn_replace_VkBuffer_handle(&((VkBuffer *)args->pCounterBuffers)[i]); |
| } |
| /* skip args->pCounterBufferOffsets */ |
| } |
| |
| static inline void vn_encode_vkCmdEndTransformFeedbackEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndTransformFeedbackEXT *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->firstCounterBuffer */ |
| /* skip args->counterBufferCount */ |
| /* skip args->pCounterBuffers */ |
| /* skip args->pCounterBufferOffsets */ |
| } |
| |
| static inline void vn_decode_vkCmdBeginQueryIndexedEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginQueryIndexedEXT *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->query); |
| vn_decode_VkFlags(dec, &args->flags); |
| vn_decode_uint32_t(dec, &args->index); |
| } |
| |
| static inline void vn_replace_vkCmdBeginQueryIndexedEXT_args_handle(struct vn_command_vkCmdBeginQueryIndexedEXT *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->query */ |
| /* skip args->flags */ |
| /* skip args->index */ |
| } |
| |
| static inline void vn_encode_vkCmdBeginQueryIndexedEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginQueryIndexedEXT *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->queryPool */ |
| /* skip args->query */ |
| /* skip args->flags */ |
| /* skip args->index */ |
| } |
| |
| static inline void vn_decode_vkCmdEndQueryIndexedEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndQueryIndexedEXT *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_VkQueryPool_lookup(dec, &args->queryPool); |
| vn_decode_uint32_t(dec, &args->query); |
| vn_decode_uint32_t(dec, &args->index); |
| } |
| |
| static inline void vn_replace_vkCmdEndQueryIndexedEXT_args_handle(struct vn_command_vkCmdEndQueryIndexedEXT *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| vn_replace_VkQueryPool_handle(&args->queryPool); |
| /* skip args->query */ |
| /* skip args->index */ |
| } |
| |
| static inline void vn_encode_vkCmdEndQueryIndexedEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndQueryIndexedEXT *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->queryPool */ |
| /* skip args->query */ |
| /* skip args->index */ |
| } |
| |
| static inline void vn_decode_vkCmdDrawIndirectByteCountEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndirectByteCountEXT *args) |
| { |
| vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer); |
| vn_decode_uint32_t(dec, &args->instanceCount); |
| vn_decode_uint32_t(dec, &args->firstInstance); |
| vn_decode_VkBuffer_lookup(dec, &args->counterBuffer); |
| vn_decode_VkDeviceSize(dec, &args->counterBufferOffset); |
| vn_decode_uint32_t(dec, &args->counterOffset); |
| vn_decode_uint32_t(dec, &args->vertexStride); |
| } |
| |
| static inline void vn_replace_vkCmdDrawIndirectByteCountEXT_args_handle(struct vn_command_vkCmdDrawIndirectByteCountEXT *args) |
| { |
| vn_replace_VkCommandBuffer_handle(&args->commandBuffer); |
| /* skip args->instanceCount */ |
| /* skip args->firstInstance */ |
| vn_replace_VkBuffer_handle(&args->counterBuffer); |
| /* skip args->counterBufferOffset */ |
| /* skip args->counterOffset */ |
| /* skip args->vertexStride */ |
| } |
| |
| static inline void vn_encode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndirectByteCountEXT *args) |
| { |
| vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT}); |
| |
| /* skip args->commandBuffer */ |
| /* skip args->instanceCount */ |
| /* skip args->firstInstance */ |
| /* skip args->counterBuffer */ |
| /* skip args->counterBufferOffset */ |
| /* skip args->counterOffset */ |
| /* skip args->vertexStride */ |
| } |
| |
| static inline void vn_dispatch_vkAllocateCommandBuffers(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkAllocateCommandBuffers args; |
| |
| if (!ctx->dispatch_vkAllocateCommandBuffers) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkAllocateCommandBuffers_args_temp(ctx->decoder, &args); |
| if (!args.device) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkAllocateCommandBuffers(ctx, &args); |
| |
| #ifdef DEBUG |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret)) |
| vn_dispatch_debug_log(ctx, "vkAllocateCommandBuffers returned %d", args.ret); |
| #endif |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkAllocateCommandBuffers_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkFreeCommandBuffers(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkFreeCommandBuffers args; |
| |
| if (!ctx->dispatch_vkFreeCommandBuffers) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkFreeCommandBuffers_args_temp(ctx->decoder, &args); |
| if (!args.device) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkFreeCommandBuffers(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkFreeCommandBuffers_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkBeginCommandBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkBeginCommandBuffer args; |
| |
| if (!ctx->dispatch_vkBeginCommandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkBeginCommandBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkBeginCommandBuffer(ctx, &args); |
| |
| #ifdef DEBUG |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret)) |
| vn_dispatch_debug_log(ctx, "vkBeginCommandBuffer returned %d", args.ret); |
| #endif |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkBeginCommandBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkEndCommandBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkEndCommandBuffer args; |
| |
| if (!ctx->dispatch_vkEndCommandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkEndCommandBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkEndCommandBuffer(ctx, &args); |
| |
| #ifdef DEBUG |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret)) |
| vn_dispatch_debug_log(ctx, "vkEndCommandBuffer returned %d", args.ret); |
| #endif |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkEndCommandBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkResetCommandBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkResetCommandBuffer args; |
| |
| if (!ctx->dispatch_vkResetCommandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkResetCommandBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkResetCommandBuffer(ctx, &args); |
| |
| #ifdef DEBUG |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret)) |
| vn_dispatch_debug_log(ctx, "vkResetCommandBuffer returned %d", args.ret); |
| #endif |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkResetCommandBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBindPipeline(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBindPipeline args; |
| |
| if (!ctx->dispatch_vkCmdBindPipeline) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBindPipeline_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBindPipeline(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBindPipeline_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetViewport(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetViewport args; |
| |
| if (!ctx->dispatch_vkCmdSetViewport) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetViewport_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetViewport(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetViewport_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetScissor(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetScissor args; |
| |
| if (!ctx->dispatch_vkCmdSetScissor) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetScissor_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetScissor(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetScissor_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetLineWidth(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetLineWidth args; |
| |
| if (!ctx->dispatch_vkCmdSetLineWidth) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetLineWidth_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetLineWidth(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetLineWidth_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetDepthBias(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetDepthBias args; |
| |
| if (!ctx->dispatch_vkCmdSetDepthBias) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetDepthBias_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetDepthBias(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetDepthBias_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetBlendConstants(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetBlendConstants args; |
| |
| if (!ctx->dispatch_vkCmdSetBlendConstants) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetBlendConstants_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetBlendConstants(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetBlendConstants_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetDepthBounds(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetDepthBounds args; |
| |
| if (!ctx->dispatch_vkCmdSetDepthBounds) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetDepthBounds_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetDepthBounds(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetDepthBounds_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetStencilCompareMask(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetStencilCompareMask args; |
| |
| if (!ctx->dispatch_vkCmdSetStencilCompareMask) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetStencilCompareMask_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetStencilCompareMask(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetStencilCompareMask_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetStencilWriteMask(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetStencilWriteMask args; |
| |
| if (!ctx->dispatch_vkCmdSetStencilWriteMask) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetStencilWriteMask_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetStencilWriteMask(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetStencilWriteMask_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetStencilReference(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetStencilReference args; |
| |
| if (!ctx->dispatch_vkCmdSetStencilReference) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetStencilReference_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetStencilReference(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetStencilReference_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBindDescriptorSets(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBindDescriptorSets args; |
| |
| if (!ctx->dispatch_vkCmdBindDescriptorSets) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBindDescriptorSets_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBindDescriptorSets(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBindDescriptorSets_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBindIndexBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBindIndexBuffer args; |
| |
| if (!ctx->dispatch_vkCmdBindIndexBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBindIndexBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBindIndexBuffer(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBindIndexBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBindVertexBuffers(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBindVertexBuffers args; |
| |
| if (!ctx->dispatch_vkCmdBindVertexBuffers) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBindVertexBuffers_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBindVertexBuffers(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBindVertexBuffers_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDraw(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDraw args; |
| |
| if (!ctx->dispatch_vkCmdDraw) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDraw_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDraw(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDraw_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDrawIndexed(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDrawIndexed args; |
| |
| if (!ctx->dispatch_vkCmdDrawIndexed) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDrawIndexed_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDrawIndexed(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDrawIndexed_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDrawIndirect(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDrawIndirect args; |
| |
| if (!ctx->dispatch_vkCmdDrawIndirect) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDrawIndirect_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDrawIndirect(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDrawIndirect_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDrawIndexedIndirect(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDrawIndexedIndirect args; |
| |
| if (!ctx->dispatch_vkCmdDrawIndexedIndirect) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDrawIndexedIndirect_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDrawIndexedIndirect(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDrawIndexedIndirect_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDispatch(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDispatch args; |
| |
| if (!ctx->dispatch_vkCmdDispatch) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDispatch_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDispatch(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDispatch_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDispatchIndirect(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDispatchIndirect args; |
| |
| if (!ctx->dispatch_vkCmdDispatchIndirect) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDispatchIndirect_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDispatchIndirect(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDispatchIndirect_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdCopyBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdCopyBuffer args; |
| |
| if (!ctx->dispatch_vkCmdCopyBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdCopyBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdCopyBuffer(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdCopyBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdCopyImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdCopyImage args; |
| |
| if (!ctx->dispatch_vkCmdCopyImage) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdCopyImage_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdCopyImage(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdCopyImage_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBlitImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBlitImage args; |
| |
| if (!ctx->dispatch_vkCmdBlitImage) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBlitImage_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBlitImage(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBlitImage_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdCopyBufferToImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdCopyBufferToImage args; |
| |
| if (!ctx->dispatch_vkCmdCopyBufferToImage) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdCopyBufferToImage_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdCopyBufferToImage(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdCopyBufferToImage_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdCopyImageToBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdCopyImageToBuffer args; |
| |
| if (!ctx->dispatch_vkCmdCopyImageToBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdCopyImageToBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdCopyImageToBuffer(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdCopyImageToBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdUpdateBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdUpdateBuffer args; |
| |
| if (!ctx->dispatch_vkCmdUpdateBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdUpdateBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdUpdateBuffer(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdUpdateBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdFillBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdFillBuffer args; |
| |
| if (!ctx->dispatch_vkCmdFillBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdFillBuffer_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdFillBuffer(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdFillBuffer_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdClearColorImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdClearColorImage args; |
| |
| if (!ctx->dispatch_vkCmdClearColorImage) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdClearColorImage_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdClearColorImage(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdClearColorImage_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdClearDepthStencilImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdClearDepthStencilImage args; |
| |
| if (!ctx->dispatch_vkCmdClearDepthStencilImage) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdClearDepthStencilImage_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdClearDepthStencilImage(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdClearDepthStencilImage_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdClearAttachments(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdClearAttachments args; |
| |
| if (!ctx->dispatch_vkCmdClearAttachments) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdClearAttachments_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdClearAttachments(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdClearAttachments_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdResolveImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdResolveImage args; |
| |
| if (!ctx->dispatch_vkCmdResolveImage) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdResolveImage_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdResolveImage(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdResolveImage_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetEvent(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetEvent args; |
| |
| if (!ctx->dispatch_vkCmdSetEvent) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetEvent_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetEvent(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetEvent_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdResetEvent(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdResetEvent args; |
| |
| if (!ctx->dispatch_vkCmdResetEvent) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdResetEvent_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdResetEvent(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdResetEvent_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdWaitEvents(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdWaitEvents args; |
| |
| if (!ctx->dispatch_vkCmdWaitEvents) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdWaitEvents_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdWaitEvents(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdWaitEvents_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdPipelineBarrier(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdPipelineBarrier args; |
| |
| if (!ctx->dispatch_vkCmdPipelineBarrier) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdPipelineBarrier_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdPipelineBarrier(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdPipelineBarrier_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBeginQuery(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBeginQuery args; |
| |
| if (!ctx->dispatch_vkCmdBeginQuery) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBeginQuery_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBeginQuery(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBeginQuery_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdEndQuery(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdEndQuery args; |
| |
| if (!ctx->dispatch_vkCmdEndQuery) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdEndQuery_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdEndQuery(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdEndQuery_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdResetQueryPool(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdResetQueryPool args; |
| |
| if (!ctx->dispatch_vkCmdResetQueryPool) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdResetQueryPool_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdResetQueryPool(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdResetQueryPool_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdWriteTimestamp(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdWriteTimestamp args; |
| |
| if (!ctx->dispatch_vkCmdWriteTimestamp) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdWriteTimestamp_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdWriteTimestamp(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdWriteTimestamp_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdCopyQueryPoolResults(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdCopyQueryPoolResults args; |
| |
| if (!ctx->dispatch_vkCmdCopyQueryPoolResults) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdCopyQueryPoolResults_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdCopyQueryPoolResults(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdCopyQueryPoolResults_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdPushConstants(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdPushConstants args; |
| |
| if (!ctx->dispatch_vkCmdPushConstants) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdPushConstants_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdPushConstants(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdPushConstants_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBeginRenderPass(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBeginRenderPass args; |
| |
| if (!ctx->dispatch_vkCmdBeginRenderPass) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBeginRenderPass_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBeginRenderPass(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBeginRenderPass_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdNextSubpass(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdNextSubpass args; |
| |
| if (!ctx->dispatch_vkCmdNextSubpass) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdNextSubpass_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdNextSubpass(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdNextSubpass_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdEndRenderPass(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdEndRenderPass args; |
| |
| if (!ctx->dispatch_vkCmdEndRenderPass) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdEndRenderPass_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdEndRenderPass(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdEndRenderPass_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdExecuteCommands(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdExecuteCommands args; |
| |
| if (!ctx->dispatch_vkCmdExecuteCommands) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdExecuteCommands_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdExecuteCommands(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdExecuteCommands_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdSetDeviceMask(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdSetDeviceMask args; |
| |
| if (!ctx->dispatch_vkCmdSetDeviceMask) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdSetDeviceMask_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdSetDeviceMask(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdSetDeviceMask_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDispatchBase(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDispatchBase args; |
| |
| if (!ctx->dispatch_vkCmdDispatchBase) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDispatchBase_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDispatchBase(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDispatchBase_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBeginRenderPass2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBeginRenderPass2 args; |
| |
| if (!ctx->dispatch_vkCmdBeginRenderPass2) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBeginRenderPass2_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBeginRenderPass2(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBeginRenderPass2_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdNextSubpass2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdNextSubpass2 args; |
| |
| if (!ctx->dispatch_vkCmdNextSubpass2) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdNextSubpass2_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdNextSubpass2(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdNextSubpass2_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdEndRenderPass2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdEndRenderPass2 args; |
| |
| if (!ctx->dispatch_vkCmdEndRenderPass2) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdEndRenderPass2_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdEndRenderPass2(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdEndRenderPass2_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDrawIndirectCount(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDrawIndirectCount args; |
| |
| if (!ctx->dispatch_vkCmdDrawIndirectCount) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDrawIndirectCount_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDrawIndirectCount(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDrawIndirectCount_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDrawIndexedIndirectCount(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDrawIndexedIndirectCount args; |
| |
| if (!ctx->dispatch_vkCmdDrawIndexedIndirectCount) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDrawIndexedIndirectCount_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDrawIndexedIndirectCount(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDrawIndexedIndirectCount_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBindTransformFeedbackBuffersEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBindTransformFeedbackBuffersEXT args; |
| |
| if (!ctx->dispatch_vkCmdBindTransformFeedbackBuffersEXT) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBindTransformFeedbackBuffersEXT_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBindTransformFeedbackBuffersEXT(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBindTransformFeedbackBuffersEXT_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBeginTransformFeedbackEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBeginTransformFeedbackEXT args; |
| |
| if (!ctx->dispatch_vkCmdBeginTransformFeedbackEXT) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBeginTransformFeedbackEXT_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBeginTransformFeedbackEXT(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBeginTransformFeedbackEXT_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdEndTransformFeedbackEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdEndTransformFeedbackEXT args; |
| |
| if (!ctx->dispatch_vkCmdEndTransformFeedbackEXT) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdEndTransformFeedbackEXT_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdEndTransformFeedbackEXT(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdEndTransformFeedbackEXT_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdBeginQueryIndexedEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdBeginQueryIndexedEXT args; |
| |
| if (!ctx->dispatch_vkCmdBeginQueryIndexedEXT) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdBeginQueryIndexedEXT_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdBeginQueryIndexedEXT(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdBeginQueryIndexedEXT_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdEndQueryIndexedEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdEndQueryIndexedEXT args; |
| |
| if (!ctx->dispatch_vkCmdEndQueryIndexedEXT) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdEndQueryIndexedEXT_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdEndQueryIndexedEXT(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdEndQueryIndexedEXT_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| static inline void vn_dispatch_vkCmdDrawIndirectByteCountEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) |
| { |
| struct vn_command_vkCmdDrawIndirectByteCountEXT args; |
| |
| if (!ctx->dispatch_vkCmdDrawIndirectByteCountEXT) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| vn_decode_vkCmdDrawIndirectByteCountEXT_args_temp(ctx->decoder, &args); |
| if (!args.commandBuffer) { |
| vn_cs_decoder_set_fatal(ctx->decoder); |
| return; |
| } |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder)) |
| ctx->dispatch_vkCmdDrawIndirectByteCountEXT(ctx, &args); |
| |
| |
| if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT)) |
| vn_encode_vkCmdDrawIndirectByteCountEXT_reply(ctx->encoder, &args); |
| |
| vn_cs_decoder_reset_temp_pool(ctx->decoder); |
| } |
| |
| #pragma GCC diagnostic pop |
| |
| #endif /* VN_PROTOCOL_RENDERER_COMMAND_BUFFER_H */ |