diff --git a/src/virtio/venus-protocol/vn_protocol_driver.h b/src/virtio/venus-protocol/vn_protocol_driver.h new file mode 100644 index 00000000000..315a450a358 --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver.h @@ -0,0 +1,20 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_H +#define VN_PROTOCOL_DRIVER_H + +#include "vn_protocol_driver_cs.h" +#include "vn_protocol_driver_defines.h" +#include "vn_protocol_driver_info.h" +#include "vn_protocol_driver_types.h" +#include "vn_protocol_driver_handles.h" +#include "vn_protocol_driver_structs.h" +#include "vn_protocol_driver_commands.h" +#include "vn_protocol_driver_calls.h" + +#endif /* VN_PROTOCOL_DRIVER_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_calls.h b/src/virtio/venus-protocol/vn_protocol_driver_calls.h new file mode 100644 index 00000000000..536bb5e141a --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_calls.h @@ -0,0 +1,7176 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_CALLS_H +#define VN_PROTOCOL_DRIVER_CALLS_H + +#include "vn_protocol_driver_commands.h" +#include "vn_device.h" + +#define VN_SUBMIT_LOCAL_CMD_SIZE 256 + +static inline void vn_submit_vkCreateInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateInstance(pCreateInfo, pAllocator, pInstance); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateInstance(&submit->command, cmd_flags, pCreateInfo, pAllocator, pInstance); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateInstance_reply(pCreateInfo, pAllocator, pInstance) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyInstance(instance, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyInstance(&submit->command, cmd_flags, instance, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyInstance_reply(instance, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumeratePhysicalDevices(&submit->command, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceProperties(&submit->command, cmd_flags, physicalDevice, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceMemoryProperties(&submit->command, cmd_flags, physicalDevice, pMemoryProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceFeatures(&submit->command, cmd_flags, physicalDevice, pFeatures); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceFormatProperties(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateDevice(&submit->command, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyDevice(&submit->command, cmd_flags, device, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumerateInstanceVersion(pApiVersion); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumerateInstanceVersion(&submit->command, cmd_flags, pApiVersion); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceVersion_reply(pApiVersion) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumerateInstanceLayerProperties(&submit->command, cmd_flags, pPropertyCount, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceLayerProperties_reply(pPropertyCount, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumerateInstanceExtensionProperties(&submit->command, cmd_flags, pLayerName, pPropertyCount, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(pLayerName, pPropertyCount, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumerateDeviceLayerProperties(&submit->command, cmd_flags, physicalDevice, pPropertyCount, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumerateDeviceExtensionProperties(&submit->command, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetDeviceQueue(&submit->command, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkQueueSubmit(queue, submitCount, pSubmits, fence); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkQueueSubmit(&submit->command, cmd_flags, queue, submitCount, pSubmits, fence); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit_reply(queue, submitCount, pSubmits, fence) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkQueueWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkQueueWaitIdle(queue); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkQueueWaitIdle(&submit->command, cmd_flags, queue); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueWaitIdle_reply(queue) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDeviceWaitIdle(&submit->command, cmd_flags, device); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkAllocateMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkAllocateMemory(&submit->command, cmd_flags, device, pAllocateInfo, pAllocator, pMemory); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateMemory_reply(device, pAllocateInfo, pAllocator, pMemory) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkFreeMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkFreeMemory(device, memory, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkFreeMemory(&submit->command, cmd_flags, device, memory, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeMemory_reply(device, memory, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkUnmapMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkUnmapMemory(device, memory); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkUnmapMemory(&submit->command, cmd_flags, device, memory); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUnmapMemory_reply(device, memory) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkFlushMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFlushMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkInvalidateMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkInvalidateMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetDeviceMemoryCommitment(&submit->command, cmd_flags, device, memory, pCommittedMemoryInBytes); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryCommitment_reply(device, memory, pCommittedMemoryInBytes) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetBufferMemoryRequirements(&submit->command, cmd_flags, device, buffer, pMemoryRequirements); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements_reply(device, buffer, pMemoryRequirements) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkBindBufferMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkBindBufferMemory(device, buffer, memory, memoryOffset); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkBindBufferMemory(&submit->command, cmd_flags, device, buffer, memory, memoryOffset); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory_reply(device, buffer, memory, memoryOffset) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetImageMemoryRequirements(&submit->command, cmd_flags, device, image, pMemoryRequirements); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkBindImageMemory(&submit->command, cmd_flags, device, image, memory, memoryOffset); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetImageSparseMemoryRequirements(&submit->command, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkQueueBindSparse(&submit->command, cmd_flags, queue, bindInfoCount, pBindInfo, fence); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueBindSparse_reply(queue, bindInfoCount, pBindInfo, fence) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateFence(device, pCreateInfo, pAllocator, pFence); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateFence(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFence); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFence_reply(device, pCreateInfo, pAllocator, pFence) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyFence(device, fence, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyFence(&submit->command, cmd_flags, device, fence, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFence_reply(device, fence, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkResetFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkResetFences(device, fenceCount, pFences); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkResetFences(&submit->command, cmd_flags, device, fenceCount, pFences); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFences_reply(device, fenceCount, pFences) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetFenceStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetFenceStatus(device, fence); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetFenceStatus(&submit->command, cmd_flags, device, fence); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetFenceStatus_reply(device, fence) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkWaitForFences(&submit->command, cmd_flags, device, fenceCount, pFences, waitAll, timeout); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitForFences_reply(device, fenceCount, pFences, waitAll, timeout) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateSemaphore(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroySemaphore(device, semaphore, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroySemaphore(&submit->command, cmd_flags, device, semaphore, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateEvent(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pEvent); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateEvent_reply(device, pCreateInfo, pAllocator, pEvent) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyEvent(device, event, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyEvent(&submit->command, cmd_flags, device, event, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyEvent_reply(device, event, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetEventStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetEventStatus(device, event); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetEventStatus(&submit->command, cmd_flags, device, event); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetEventStatus_reply(device, event) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkSetEvent(device, event); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkSetEvent(&submit->command, cmd_flags, device, event); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetEvent_reply(device, event) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkResetEvent(device, event); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkResetEvent(&submit->command, cmd_flags, device, event); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetEvent_reply(device, event) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateQueryPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pQueryPool); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateQueryPool_reply(device, pCreateInfo, pAllocator, pQueryPool) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyQueryPool(device, queryPool, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyQueryPool(&submit->command, cmd_flags, device, queryPool, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyQueryPool_reply(device, queryPool, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetQueryPoolResults(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetQueryPoolResults_reply(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkResetQueryPool(device, queryPool, firstQuery, queryCount); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkResetQueryPool(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetQueryPool_reply(device, queryPool, firstQuery, queryCount) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateBuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pBuffer); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBuffer_reply(device, pCreateInfo, pAllocator, pBuffer) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyBuffer(device, buffer, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyBuffer(&submit->command, cmd_flags, device, buffer, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBuffer_reply(device, buffer, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateBufferView(device, pCreateInfo, pAllocator, pView); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateBufferView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyBufferView(device, bufferView, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyBufferView(&submit->command, cmd_flags, device, bufferView, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateImage(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pImage); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyImage(&submit->command, cmd_flags, device, image, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetImageSubresourceLayout(&submit->command, cmd_flags, device, image, pSubresource, pLayout); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateImageView(device, pCreateInfo, pAllocator, pView); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateImageView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImageView_reply(device, pCreateInfo, pAllocator, pView) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyImageView(device, imageView, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyImageView(&submit->command, cmd_flags, device, imageView, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImageView_reply(device, imageView, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateShaderModule(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pShaderModule); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateShaderModule_reply(device, pCreateInfo, pAllocator, pShaderModule) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyShaderModule(device, shaderModule, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyShaderModule(&submit->command, cmd_flags, device, shaderModule, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyShaderModule_reply(device, shaderModule, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreatePipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreatePipelineCache(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineCache); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineCache_reply(device, pCreateInfo, pAllocator, pPipelineCache) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyPipelineCache(device, pipelineCache, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyPipelineCache(&submit->command, cmd_flags, device, pipelineCache, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineCache_reply(device, pipelineCache, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPipelineCacheData(&submit->command, cmd_flags, device, pipelineCache, pDataSize, pData); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPipelineCacheData_reply(device, pipelineCache, pDataSize, pData) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkMergePipelineCaches(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkMergePipelineCaches(&submit->command, cmd_flags, device, dstCache, srcCacheCount, pSrcCaches); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkMergePipelineCaches_reply(device, dstCache, srcCacheCount, pSrcCaches) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateGraphicsPipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateComputePipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateComputePipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyPipeline(device, pipeline, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyPipeline(&submit->command, cmd_flags, device, pipeline, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreatePipelineLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineLayout); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineLayout_reply(device, pCreateInfo, pAllocator, pPipelineLayout) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyPipelineLayout(&submit->command, cmd_flags, device, pipelineLayout, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineLayout_reply(device, pipelineLayout, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateSampler(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSampler); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroySampler(device, sampler, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroySampler(&submit->command, cmd_flags, device, sampler, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateDescriptorSetLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSetLayout); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorSetLayout_reply(device, pCreateInfo, pAllocator, pSetLayout) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyDescriptorSetLayout(&submit->command, cmd_flags, device, descriptorSetLayout, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorSetLayout_reply(device, descriptorSetLayout, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateDescriptorPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyDescriptorPool(device, descriptorPool, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkResetDescriptorPool(device, descriptorPool, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkResetDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkAllocateDescriptorSets(&submit->command, cmd_flags, device, pAllocateInfo, pDescriptorSets); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateDescriptorSets_reply(device, pAllocateInfo, pDescriptorSets) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkFreeDescriptorSets(&submit->command, cmd_flags, device, descriptorPool, descriptorSetCount, pDescriptorSets); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeDescriptorSets_reply(device, descriptorPool, descriptorSetCount, pDescriptorSets) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkUpdateDescriptorSets(&submit->command, cmd_flags, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUpdateDescriptorSets_reply(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateFramebuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFramebuffer); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFramebuffer_reply(device, pCreateInfo, pAllocator, pFramebuffer) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyFramebuffer(device, framebuffer, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyFramebuffer(&submit->command, cmd_flags, device, framebuffer, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFramebuffer_reply(device, framebuffer, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateRenderPass(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyRenderPass(device, renderPass, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyRenderPass(&submit->command, cmd_flags, device, renderPass, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetRenderAreaGranularity(device, renderPass, pGranularity); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetRenderAreaGranularity(&submit->command, cmd_flags, device, renderPass, pGranularity); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateCommandPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyCommandPool(device, commandPool, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyCommandPool(&submit->command, cmd_flags, device, commandPool, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkResetCommandPool(device, commandPool, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkResetCommandPool(&submit->command, cmd_flags, device, commandPool, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkAllocateCommandBuffers(&submit->command, cmd_flags, device, pAllocateInfo, pCommandBuffers); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateCommandBuffers_reply(device, pAllocateInfo, pCommandBuffers) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkFreeCommandBuffers(&submit->command, cmd_flags, device, commandPool, commandBufferCount, pCommandBuffers); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeCommandBuffers_reply(device, commandPool, commandBufferCount, pCommandBuffers) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkBeginCommandBuffer(commandBuffer, pBeginInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkBeginCommandBuffer(&submit->command, cmd_flags, commandBuffer, pBeginInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBeginCommandBuffer_reply(commandBuffer, pBeginInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEndCommandBuffer(commandBuffer); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEndCommandBuffer(&submit->command, cmd_flags, commandBuffer); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEndCommandBuffer_reply(commandBuffer) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkResetCommandBuffer(commandBuffer, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkResetCommandBuffer(&submit->command, cmd_flags, commandBuffer, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandBuffer_reply(commandBuffer, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBindPipeline(&submit->command, cmd_flags, commandBuffer, pipelineBindPoint, pipeline); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindPipeline_reply(commandBuffer, pipelineBindPoint, pipeline) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetViewport(&submit->command, cmd_flags, commandBuffer, firstViewport, viewportCount, pViewports); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetViewport_reply(commandBuffer, firstViewport, viewportCount, pViewports) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetScissor(&submit->command, cmd_flags, commandBuffer, firstScissor, scissorCount, pScissors); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetScissor_reply(commandBuffer, firstScissor, scissorCount, pScissors) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float lineWidth, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetLineWidth(commandBuffer, lineWidth); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetLineWidth(&submit->command, cmd_flags, commandBuffer, lineWidth); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetLineWidth_reply(commandBuffer, lineWidth) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetDepthBias(&submit->command, cmd_flags, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBias_reply(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const float blendConstants[4], struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetBlendConstants(commandBuffer, blendConstants); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetBlendConstants(&submit->command, cmd_flags, commandBuffer, blendConstants); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetBlendConstants_reply(commandBuffer, blendConstants) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetDepthBounds(&submit->command, cmd_flags, commandBuffer, minDepthBounds, maxDepthBounds); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDepthBounds_reply(commandBuffer, minDepthBounds, maxDepthBounds) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetStencilCompareMask(&submit->command, cmd_flags, commandBuffer, faceMask, compareMask); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilCompareMask_reply(commandBuffer, faceMask, compareMask) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetStencilWriteMask(&submit->command, cmd_flags, commandBuffer, faceMask, writeMask); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilWriteMask_reply(commandBuffer, faceMask, writeMask) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetStencilReference(commandBuffer, faceMask, reference); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetStencilReference(&submit->command, cmd_flags, commandBuffer, faceMask, reference); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetStencilReference_reply(commandBuffer, faceMask, reference) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBindDescriptorSets(&submit->command, cmd_flags, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindDescriptorSets_reply(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBindIndexBuffer(&submit->command, cmd_flags, commandBuffer, buffer, offset, indexType); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindIndexBuffer_reply(commandBuffer, buffer, offset, indexType) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBindVertexBuffers(&submit->command, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindVertexBuffers_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDraw(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDraw(&submit->command, cmd_flags, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDraw_reply(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDrawIndexed(&submit->command, cmd_flags, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexed_reply(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDrawIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset, drawCount, stride); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirect_reply(commandBuffer, buffer, offset, drawCount, stride) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDrawIndexedIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset, drawCount, stride); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexedIndirect_reply(commandBuffer, buffer, offset, drawCount, stride) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDispatch(&submit->command, cmd_flags, commandBuffer, groupCountX, groupCountY, groupCountZ); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatch_reply(commandBuffer, groupCountX, groupCountY, groupCountZ) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDispatchIndirect(commandBuffer, buffer, offset); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDispatchIndirect(&submit->command, cmd_flags, commandBuffer, buffer, offset); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatchIndirect_reply(commandBuffer, buffer, offset) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdCopyBuffer(&submit->command, cmd_flags, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBuffer_reply(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdCopyImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBlitImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBlitImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdCopyBufferToImage(&submit->command, cmd_flags, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyBufferToImage_reply(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdCopyImageToBuffer(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyImageToBuffer_reply(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdUpdateBuffer(&submit->command, cmd_flags, commandBuffer, dstBuffer, dstOffset, dataSize, pData); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdUpdateBuffer_reply(commandBuffer, dstBuffer, dstOffset, dataSize, pData) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdFillBuffer(&submit->command, cmd_flags, commandBuffer, dstBuffer, dstOffset, size, data); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdFillBuffer_reply(commandBuffer, dstBuffer, dstOffset, size, data) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdClearColorImage(&submit->command, cmd_flags, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearColorImage_reply(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdClearDepthStencilImage(&submit->command, cmd_flags, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearDepthStencilImage_reply(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdClearAttachments(&submit->command, cmd_flags, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdClearAttachments_reply(commandBuffer, attachmentCount, pAttachments, rectCount, pRects) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdResolveImage(&submit->command, cmd_flags, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResolveImage_reply(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetEvent(commandBuffer, event, stageMask); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetEvent(&submit->command, cmd_flags, commandBuffer, event, stageMask); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetEvent_reply(commandBuffer, event, stageMask) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdResetEvent(commandBuffer, event, stageMask); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdResetEvent(&submit->command, cmd_flags, commandBuffer, event, stageMask); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetEvent_reply(commandBuffer, event, stageMask) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdWaitEvents(&submit->command, cmd_flags, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWaitEvents_reply(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdPipelineBarrier(&submit->command, cmd_flags, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPipelineBarrier_reply(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBeginQuery(commandBuffer, queryPool, query, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBeginQuery(&submit->command, cmd_flags, commandBuffer, queryPool, query, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginQuery_reply(commandBuffer, queryPool, query, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdEndQuery(commandBuffer, queryPool, query); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdEndQuery(&submit->command, cmd_flags, commandBuffer, queryPool, query); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndQuery_reply(commandBuffer, queryPool, query) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdResetQueryPool(&submit->command, cmd_flags, commandBuffer, queryPool, firstQuery, queryCount); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdResetQueryPool_reply(commandBuffer, queryPool, firstQuery, queryCount) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdWriteTimestamp(&submit->command, cmd_flags, commandBuffer, pipelineStage, queryPool, query); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdWriteTimestamp_reply(commandBuffer, pipelineStage, queryPool, query) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdCopyQueryPoolResults(&submit->command, cmd_flags, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdCopyQueryPoolResults_reply(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdPushConstants(&submit->command, cmd_flags, commandBuffer, layout, stageFlags, offset, size, pValues); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdPushConstants_reply(commandBuffer, layout, stageFlags, offset, size, pValues) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBeginRenderPass(&submit->command, cmd_flags, commandBuffer, pRenderPassBegin, contents); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRenderPass_reply(commandBuffer, pRenderPassBegin, contents) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkSubpassContents contents, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdNextSubpass(commandBuffer, contents); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdNextSubpass(&submit->command, cmd_flags, commandBuffer, contents); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdNextSubpass_reply(commandBuffer, contents) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdEndRenderPass(commandBuffer); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdEndRenderPass(&submit->command, cmd_flags, commandBuffer); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRenderPass_reply(commandBuffer) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdExecuteCommands(&submit->command, cmd_flags, commandBuffer, commandBufferCount, pCommandBuffers); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdExecuteCommands_reply(commandBuffer, commandBufferCount, pCommandBuffers) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceFeatures2(&submit->command, cmd_flags, physicalDevice, pFeatures); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceProperties2(&submit->command, cmd_flags, physicalDevice, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceFormatProperties2(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceMemoryProperties2(&submit->command, cmd_flags, physicalDevice, pMemoryProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkTrimCommandPool(device, commandPool, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkTrimCommandPool(&submit->command, cmd_flags, device, commandPool, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceExternalBufferProperties(&submit->command, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(&submit->command, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetPhysicalDeviceExternalFenceProperties(&submit->command, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkEnumeratePhysicalDeviceGroups(&submit->command, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetDeviceGroupPeerMemoryFeatures(&submit->command, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkBindBufferMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkBindBufferMemory2(device, bindInfoCount, pBindInfos); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkBindBufferMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory2_reply(device, bindInfoCount, pBindInfos) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkBindImageMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t deviceMask, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdSetDeviceMask(commandBuffer, deviceMask); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdSetDeviceMask(&submit->command, cmd_flags, commandBuffer, deviceMask); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdSetDeviceMask_reply(commandBuffer, deviceMask) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDispatchBase(&submit->command, cmd_flags, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDispatchBase_reply(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateDescriptorUpdateTemplate(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyDescriptorUpdateTemplate(&submit->command, cmd_flags, device, descriptorUpdateTemplate, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(device, descriptorUpdateTemplate, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetBufferMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetImageMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetImageSparseMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateSamplerYcbcrConversion(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pYcbcrConversion); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSamplerYcbcrConversion_reply(device, pCreateInfo, pAllocator, pYcbcrConversion) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroySamplerYcbcrConversion(&submit->command, cmd_flags, device, ycbcrConversion, pAllocator); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySamplerYcbcrConversion_reply(device, ycbcrConversion, pAllocator) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetDeviceQueue2(&submit->command, cmd_flags, device, pQueueInfo, pQueue); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetDescriptorSetLayoutSupport(&submit->command, cmd_flags, device, pCreateInfo, pSupport); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(device, pCreateInfo, pSupport) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateRenderPass2(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBeginRenderPass2(&submit->command, cmd_flags, commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginRenderPass2_reply(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdNextSubpass2(&submit->command, cmd_flags, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdNextSubpass2_reply(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdEndRenderPass2(&submit->command, cmd_flags, commandBuffer, pSubpassEndInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndRenderPass2_reply(commandBuffer, pSubpassEndInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetSemaphoreCounterValue(device, semaphore, pValue); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetSemaphoreCounterValue(&submit->command, cmd_flags, device, semaphore, pValue); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkWaitSemaphores(device, pWaitInfo, timeout); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkWaitSemaphores(&submit->command, cmd_flags, device, pWaitInfo, timeout); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkSignalSemaphore(device, pSignalInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkSignalSemaphore(&submit->command, cmd_flags, device, pSignalInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDrawIndirectCount(&submit->command, cmd_flags, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirectCount_reply(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDrawIndexedIndirectCount(&submit->command, cmd_flags, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndexedIndirectCount_reply(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBindTransformFeedbackBuffersEXT(&submit->command, cmd_flags, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT_reply(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBeginTransformFeedbackEXT(&submit->command, cmd_flags, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginTransformFeedbackEXT_reply(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdEndTransformFeedbackEXT(&submit->command, cmd_flags, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndTransformFeedbackEXT_reply(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdBeginQueryIndexedEXT(&submit->command, cmd_flags, commandBuffer, queryPool, query, flags, index); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdBeginQueryIndexedEXT_reply(commandBuffer, queryPool, query, flags, index) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdEndQueryIndexedEXT(&submit->command, cmd_flags, commandBuffer, queryPool, query, index); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdEndQueryIndexedEXT_reply(commandBuffer, queryPool, query, index) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCmdDrawIndirectByteCountEXT(&submit->command, cmd_flags, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCmdDrawIndirectByteCountEXT_reply(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(&submit->command, cmd_flags, device, image, pProperties); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetBufferOpaqueCaptureAddress(device, pInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetBufferOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(device, pInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetBufferDeviceAddress(device, pInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetBufferDeviceAddress(&submit->command, cmd_flags, device, pInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferDeviceAddress_reply(device, pInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(device, pInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkSetReplyCommandStreamMESA(pStream); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkSetReplyCommandStreamMESA(&submit->command, cmd_flags, pStream); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetReplyCommandStreamMESA_reply(pStream) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, size_t position, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkSeekReplyCommandStreamMESA(position); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkSeekReplyCommandStreamMESA(&submit->command, cmd_flags, position); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSeekReplyCommandStreamMESA_reply(position) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkExecuteCommandStreamsMESA(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkExecuteCommandStreamsMESA(&submit->command, cmd_flags, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkExecuteCommandStreamsMESA_reply(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkCreateRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkCreateRingMESA(ring, pCreateInfo); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkCreateRingMESA(&submit->command, cmd_flags, ring, pCreateInfo); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRingMESA_reply(ring, pCreateInfo) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkDestroyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkDestroyRingMESA(ring); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkDestroyRingMESA(&submit->command, cmd_flags, ring); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRingMESA_reply(ring) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkNotifyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkNotifyRingMESA(ring, seqno, flags); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkNotifyRingMESA(&submit->command, cmd_flags, ring, seqno, flags); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkNotifyRingMESA_reply(ring, seqno, flags) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value, struct vn_instance_submit_command *submit) +{ + uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE]; + void *cmd_data = local_cmd_data; + size_t cmd_size = vn_sizeof_vkWriteRingExtraMESA(ring, offset, value); + if (cmd_size > sizeof(local_cmd_data)) { + cmd_data = malloc(cmd_size); + if (!cmd_data) + cmd_size = 0; + } + + submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size); + if (cmd_size) + vn_encode_vkWriteRingExtraMESA(&submit->command, cmd_flags, ring, offset, value); + submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWriteRingExtraMESA_reply(ring, offset, value) : 0; + vn_instance_submit_command(vn_instance, submit); + + if (cmd_data != local_cmd_data) + free(cmd_data); +} + +static inline VkResult vn_call_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pCreateInfo, pAllocator, pInstance, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateInstance_reply(&submit.reply, pCreateInfo, pAllocator, pInstance); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateInstance(vn_instance, 0, pCreateInfo, pAllocator, pInstance, &submit); +} + +static inline void vn_call_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyInstance_reply(&submit.reply, instance, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyInstance(vn_instance, 0, instance, pAllocator, &submit); +} + +static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(&submit.reply, instance, pPhysicalDeviceCount, pPhysicalDevices); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumeratePhysicalDevices(vn_instance, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceProperties_reply(&submit.reply, physicalDevice, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceProperties(vn_instance, 0, physicalDevice, pProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(&submit.reply, physicalDevice, pMemoryProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, 0, physicalDevice, pMemoryProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceFeatures_reply(&submit.reply, physicalDevice, pFeatures); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, 0, physicalDevice, pFeatures, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceFormatProperties_reply(&submit.reply, physicalDevice, format, pFormatProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit); +} + +static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit); +} + +static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateDevice_reply(&submit.reply, physicalDevice, pCreateInfo, pAllocator, pDevice); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDevice(vn_instance, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit); +} + +static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyDevice_reply(&submit.reply, device, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDevice(vn_instance, 0, device, pAllocator, &submit); +} + +static inline VkResult vn_call_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateInstanceVersion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pApiVersion, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumerateInstanceVersion_reply(&submit.reply, pApiVersion); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateInstanceVersion(vn_instance, 0, pApiVersion, &submit); +} + +static inline VkResult vn_call_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pPropertyCount, pProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumerateInstanceLayerProperties_reply(&submit.reply, pPropertyCount, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, 0, pPropertyCount, pProperties, &submit); +} + +static inline VkResult vn_call_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pLayerName, pPropertyCount, pProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumerateInstanceExtensionProperties_reply(&submit.reply, pLayerName, pPropertyCount, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, 0, pLayerName, pPropertyCount, pProperties, &submit); +} + +static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(&submit.reply, physicalDevice, pPropertyCount, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, 0, physicalDevice, pPropertyCount, pProperties, &submit); +} + +static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(&submit.reply, physicalDevice, pLayerName, pPropertyCount, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit); +} + +static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit); + if (submit.reply_bo) { + vn_decode_vkGetDeviceQueue_reply(&submit.reply, device, queueFamilyIndex, queueIndex, pQueue); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceQueue(vn_instance, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit); +} + +static inline VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueSubmit(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkQueueSubmit_reply(&submit.reply, queue, submitCount, pSubmits, fence); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueSubmit(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit); +} + +static inline VkResult vn_call_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkQueueWaitIdle_reply(&submit.reply, queue); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkQueueWaitIdle(struct vn_instance *vn_instance, VkQueue queue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueWaitIdle(vn_instance, 0, queue, &submit); +} + +static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(&submit.reply, device); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDeviceWaitIdle(vn_instance, 0, device, &submit); +} + +static inline VkResult vn_call_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + struct vn_instance_submit_command submit; + vn_submit_vkAllocateMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pAllocator, pMemory, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkAllocateMemory_reply(&submit.reply, device, pAllocateInfo, pAllocator, pMemory); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + struct vn_instance_submit_command submit; + vn_submit_vkAllocateMemory(vn_instance, 0, device, pAllocateInfo, pAllocator, pMemory, &submit); +} + +static inline void vn_call_vkFreeMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFreeMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkFreeMemory_reply(&submit.reply, device, memory, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkFreeMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFreeMemory(vn_instance, 0, device, memory, pAllocator, &submit); +} + +static inline void vn_call_vkUnmapMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory) +{ + struct vn_instance_submit_command submit; + vn_submit_vkUnmapMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, &submit); + if (submit.reply_bo) { + vn_decode_vkUnmapMemory_reply(&submit.reply, device, memory); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkUnmapMemory(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory) +{ + struct vn_instance_submit_command submit; + vn_submit_vkUnmapMemory(vn_instance, 0, device, memory, &submit); +} + +static inline VkResult vn_call_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFlushMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkFlushMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFlushMappedMemoryRanges(vn_instance, 0, device, memoryRangeCount, pMemoryRanges, &submit); +} + +static inline VkResult vn_call_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkInvalidateMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, 0, device, memoryRangeCount, pMemoryRanges, &submit); +} + +static inline void vn_call_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceMemoryCommitment(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pCommittedMemoryInBytes, &submit); + if (submit.reply_bo) { + vn_decode_vkGetDeviceMemoryCommitment_reply(&submit.reply, device, memory, pCommittedMemoryInBytes); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceMemoryCommitment(vn_instance, 0, device, memory, pCommittedMemoryInBytes, &submit); +} + +static inline void vn_call_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pMemoryRequirements, &submit); + if (submit.reply_bo) { + vn_decode_vkGetBufferMemoryRequirements_reply(&submit.reply, device, buffer, pMemoryRequirements); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferMemoryRequirements(vn_instance, 0, device, buffer, pMemoryRequirements, &submit); +} + +static inline VkResult vn_call_vkBindBufferMemory(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindBufferMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, memory, memoryOffset, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkBindBufferMemory_reply(&submit.reply, device, buffer, memory, memoryOffset); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkBindBufferMemory(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindBufferMemory(vn_instance, 0, device, buffer, memory, memoryOffset, &submit); +} + +static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit); + if (submit.reply_bo) { + vn_decode_vkGetImageMemoryRequirements_reply(&submit.reply, device, image, pMemoryRequirements); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageMemoryRequirements(vn_instance, 0, device, image, pMemoryRequirements, &submit); +} + +static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkBindImageMemory_reply(&submit.reply, device, image, memory, memoryOffset); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindImageMemory(vn_instance, 0, device, image, memory, memoryOffset, &submit); +} + +static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); + if (submit.reply_bo) { + vn_decode_vkGetImageSparseMemoryRequirements_reply(&submit.reply, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit); +} + +static inline VkResult vn_call_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueBindSparse(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, bindInfoCount, pBindInfo, fence, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkQueueBindSparse_reply(&submit.reply, queue, bindInfoCount, pBindInfo, fence); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkQueueBindSparse(struct vn_instance *vn_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkQueueBindSparse(vn_instance, 0, queue, bindInfoCount, pBindInfo, fence, &submit); +} + +static inline VkResult vn_call_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFence, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateFence_reply(&submit.reply, device, pCreateInfo, pAllocator, pFence); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateFence(vn_instance, 0, device, pCreateInfo, pAllocator, pFence, &submit); +} + +static inline void vn_call_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyFence_reply(&submit.reply, device, fence, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyFence(vn_instance, 0, device, fence, pAllocator, &submit); +} + +static inline VkResult vn_call_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkResetFences_reply(&submit.reply, device, fenceCount, pFences); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetFences(vn_instance, 0, device, fenceCount, pFences, &submit); +} + +static inline VkResult vn_call_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetFenceStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetFenceStatus_reply(&submit.reply, device, fence); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetFenceStatus(vn_instance, 0, device, fence, &submit); +} + +static inline VkResult vn_call_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkWaitForFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, waitAll, timeout, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkWaitForFences_reply(&submit.reply, device, fenceCount, pFences, waitAll, timeout); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkWaitForFences(vn_instance, 0, device, fenceCount, pFences, waitAll, timeout, &submit); +} + +static inline VkResult vn_call_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSemaphore, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateSemaphore_reply(&submit.reply, device, pCreateInfo, pAllocator, pSemaphore); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateSemaphore(vn_instance, 0, device, pCreateInfo, pAllocator, pSemaphore, &submit); +} + +static inline void vn_call_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroySemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroySemaphore_reply(&submit.reply, device, semaphore, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroySemaphore(vn_instance, 0, device, semaphore, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pEvent, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateEvent_reply(&submit.reply, device, pCreateInfo, pAllocator, pEvent); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateEvent(vn_instance, 0, device, pCreateInfo, pAllocator, pEvent, &submit); +} + +static inline void vn_call_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyEvent_reply(&submit.reply, device, event, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyEvent(vn_instance, 0, device, event, pAllocator, &submit); +} + +static inline VkResult vn_call_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetEventStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetEventStatus_reply(&submit.reply, device, event); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetEventStatus(vn_instance, 0, device, event, &submit); +} + +static inline VkResult vn_call_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkSetEvent_reply(&submit.reply, device, event); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSetEvent(vn_instance, 0, device, event, &submit); +} + +static inline VkResult vn_call_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkResetEvent_reply(&submit.reply, device, event); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetEvent(vn_instance, 0, device, event, &submit); +} + +static inline VkResult vn_call_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pQueryPool, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateQueryPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pQueryPool); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateQueryPool(vn_instance, 0, device, pCreateInfo, pAllocator, pQueryPool, &submit); +} + +static inline void vn_call_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyQueryPool_reply(&submit.reply, device, queryPool, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyQueryPool(vn_instance, 0, device, queryPool, pAllocator, &submit); +} + +static inline VkResult vn_call_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetQueryPoolResults_reply(&submit.reply, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetQueryPoolResults(vn_instance, 0, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit); +} + +static inline void vn_call_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, &submit); + if (submit.reply_bo) { + vn_decode_vkResetQueryPool_reply(&submit.reply, device, queryPool, firstQuery, queryCount); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetQueryPool(vn_instance, 0, device, queryPool, firstQuery, queryCount, &submit); +} + +static inline VkResult vn_call_vkCreateBuffer(struct vn_instance *vn_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pBuffer, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateBuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pBuffer); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateBuffer(struct vn_instance *vn_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateBuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pBuffer, &submit); +} + +static inline void vn_call_vkDestroyBuffer(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyBuffer_reply(&submit.reply, device, buffer, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyBuffer(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyBuffer(vn_instance, 0, device, buffer, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateBufferView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateBufferView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit); +} + +static inline void vn_call_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bufferView, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyBufferView_reply(&submit.reply, device, bufferView, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyBufferView(vn_instance, 0, device, bufferView, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateImage_reply(&submit.reply, device, pCreateInfo, pAllocator, pImage); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateImage(vn_instance, 0, device, pCreateInfo, pAllocator, pImage, &submit); +} + +static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyImage_reply(&submit.reply, device, image, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyImage(vn_instance, 0, device, image, pAllocator, &submit); +} + +static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit); + if (submit.reply_bo) { + vn_decode_vkGetImageSubresourceLayout_reply(&submit.reply, device, image, pSubresource, pLayout); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageSubresourceLayout(vn_instance, 0, device, image, pSubresource, pLayout, &submit); +} + +static inline VkResult vn_call_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateImageView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateImageView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit); +} + +static inline void vn_call_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, imageView, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyImageView_reply(&submit.reply, device, imageView, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyImageView(vn_instance, 0, device, imageView, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pShaderModule, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateShaderModule_reply(&submit.reply, device, pCreateInfo, pAllocator, pShaderModule); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateShaderModule(vn_instance, 0, device, pCreateInfo, pAllocator, pShaderModule, &submit); +} + +static inline void vn_call_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, shaderModule, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyShaderModule_reply(&submit.reply, device, shaderModule, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyShaderModule(vn_instance, 0, device, shaderModule, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreatePipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineCache, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreatePipelineCache_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineCache); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreatePipelineCache(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineCache, &submit); +} + +static inline void vn_call_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyPipelineCache_reply(&submit.reply, device, pipelineCache, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPipelineCache(vn_instance, 0, device, pipelineCache, pAllocator, &submit); +} + +static inline VkResult vn_call_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPipelineCacheData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pDataSize, pData, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetPipelineCacheData_reply(&submit.reply, device, pipelineCache, pDataSize, pData); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPipelineCacheData(vn_instance, 0, device, pipelineCache, pDataSize, pData, &submit); +} + +static inline VkResult vn_call_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + struct vn_instance_submit_command submit; + vn_submit_vkMergePipelineCaches(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, dstCache, srcCacheCount, pSrcCaches, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkMergePipelineCaches_reply(&submit.reply, device, dstCache, srcCacheCount, pSrcCaches); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + struct vn_instance_submit_command submit; + vn_submit_vkMergePipelineCaches(vn_instance, 0, device, dstCache, srcCacheCount, pSrcCaches, &submit); +} + +static inline VkResult vn_call_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateGraphicsPipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateGraphicsPipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit); +} + +static inline VkResult vn_call_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateComputePipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateComputePipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateComputePipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit); +} + +static inline void vn_call_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipeline, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyPipeline_reply(&submit.reply, device, pipeline, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPipeline(vn_instance, 0, device, pipeline, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreatePipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineLayout, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreatePipelineLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineLayout); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreatePipelineLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineLayout, &submit); +} + +static inline void vn_call_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineLayout, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyPipelineLayout_reply(&submit.reply, device, pipelineLayout, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyPipelineLayout(vn_instance, 0, device, pipelineLayout, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateSampler_reply(&submit.reply, device, pCreateInfo, pAllocator, pSampler); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateSampler(vn_instance, 0, device, pCreateInfo, pAllocator, pSampler, &submit); +} + +static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroySampler_reply(&submit.reply, device, sampler, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroySampler(vn_instance, 0, device, sampler, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSetLayout, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateDescriptorSetLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pSetLayout); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDescriptorSetLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pSetLayout, &submit); +} + +static inline void vn_call_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorSetLayout, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyDescriptorSetLayout_reply(&submit.reply, device, descriptorSetLayout, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDescriptorSetLayout(vn_instance, 0, device, descriptorSetLayout, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorPool, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorPool); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDescriptorPool(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorPool, &submit); +} + +static inline void vn_call_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyDescriptorPool_reply(&submit.reply, device, descriptorPool, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDescriptorPool(vn_instance, 0, device, descriptorPool, pAllocator, &submit); +} + +static inline VkResult vn_call_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, flags, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkResetDescriptorPool_reply(&submit.reply, device, descriptorPool, flags); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetDescriptorPool(vn_instance, 0, device, descriptorPool, flags, &submit); +} + +static inline VkResult vn_call_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkAllocateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pDescriptorSets, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkAllocateDescriptorSets_reply(&submit.reply, device, pAllocateInfo, pDescriptorSets); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkAllocateDescriptorSets(vn_instance, 0, device, pAllocateInfo, pDescriptorSets, &submit); +} + +static inline VkResult vn_call_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFreeDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkFreeDescriptorSets_reply(&submit.reply, device, descriptorPool, descriptorSetCount, pDescriptorSets); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFreeDescriptorSets(vn_instance, 0, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit); +} + +static inline void vn_call_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + struct vn_instance_submit_command submit; + vn_submit_vkUpdateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit); + if (submit.reply_bo) { + vn_decode_vkUpdateDescriptorSets_reply(&submit.reply, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + struct vn_instance_submit_command submit; + vn_submit_vkUpdateDescriptorSets(vn_instance, 0, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit); +} + +static inline VkResult vn_call_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFramebuffer, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateFramebuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pFramebuffer); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateFramebuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pFramebuffer, &submit); +} + +static inline void vn_call_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, framebuffer, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyFramebuffer_reply(&submit.reply, device, framebuffer, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyFramebuffer(vn_instance, 0, device, framebuffer, pAllocator, &submit); +} + +static inline VkResult vn_call_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateRenderPass_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateRenderPass(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit); +} + +static inline void vn_call_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyRenderPass_reply(&submit.reply, device, renderPass, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyRenderPass(vn_instance, 0, device, renderPass, pAllocator, &submit); +} + +static inline void vn_call_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetRenderAreaGranularity(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit); + if (submit.reply_bo) { + vn_decode_vkGetRenderAreaGranularity_reply(&submit.reply, device, renderPass, pGranularity); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetRenderAreaGranularity(vn_instance, 0, device, renderPass, pGranularity, &submit); +} + +static inline VkResult vn_call_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pCommandPool, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateCommandPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pCommandPool); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateCommandPool(vn_instance, 0, device, pCreateInfo, pAllocator, pCommandPool, &submit); +} + +static inline void vn_call_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyCommandPool_reply(&submit.reply, device, commandPool, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyCommandPool(vn_instance, 0, device, commandPool, pAllocator, &submit); +} + +static inline VkResult vn_call_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkResetCommandPool_reply(&submit.reply, device, commandPool, flags); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetCommandPool(vn_instance, 0, device, commandPool, flags, &submit); +} + +static inline VkResult vn_call_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkAllocateCommandBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pCommandBuffers, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkAllocateCommandBuffers_reply(&submit.reply, device, pAllocateInfo, pCommandBuffers); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkAllocateCommandBuffers(struct vn_instance *vn_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkAllocateCommandBuffers(vn_instance, 0, device, pAllocateInfo, pCommandBuffers, &submit); +} + +static inline void vn_call_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFreeCommandBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, commandBufferCount, pCommandBuffers, &submit); + if (submit.reply_bo) { + vn_decode_vkFreeCommandBuffers_reply(&submit.reply, device, commandPool, commandBufferCount, pCommandBuffers); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkFreeCommandBuffers(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkFreeCommandBuffers(vn_instance, 0, device, commandPool, commandBufferCount, pCommandBuffers, &submit); +} + +static inline VkResult vn_call_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBeginCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pBeginInfo, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkBeginCommandBuffer_reply(&submit.reply, commandBuffer, pBeginInfo); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkBeginCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBeginCommandBuffer(vn_instance, 0, commandBuffer, pBeginInfo, &submit); +} + +static inline VkResult vn_call_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEndCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEndCommandBuffer_reply(&submit.reply, commandBuffer); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEndCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEndCommandBuffer(vn_instance, 0, commandBuffer, &submit); +} + +static inline VkResult vn_call_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetCommandBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, flags, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkResetCommandBuffer_reply(&submit.reply, commandBuffer, flags); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkResetCommandBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkResetCommandBuffer(vn_instance, 0, commandBuffer, flags, &submit); +} + +static inline void vn_call_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineBindPoint, pipeline, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBindPipeline_reply(&submit.reply, commandBuffer, pipelineBindPoint, pipeline); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBindPipeline(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindPipeline(vn_instance, 0, commandBuffer, pipelineBindPoint, pipeline, &submit); +} + +static inline void vn_call_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetViewport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstViewport, viewportCount, pViewports, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetViewport_reply(&submit.reply, commandBuffer, firstViewport, viewportCount, pViewports); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetViewport(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetViewport(vn_instance, 0, commandBuffer, firstViewport, viewportCount, pViewports, &submit); +} + +static inline void vn_call_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetScissor(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstScissor, scissorCount, pScissors, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetScissor_reply(&submit.reply, commandBuffer, firstScissor, scissorCount, pScissors); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetScissor(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetScissor(vn_instance, 0, commandBuffer, firstScissor, scissorCount, pScissors, &submit); +} + +static inline void vn_call_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float lineWidth) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetLineWidth(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, lineWidth, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetLineWidth_reply(&submit.reply, commandBuffer, lineWidth); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetLineWidth(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float lineWidth) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetLineWidth(vn_instance, 0, commandBuffer, lineWidth, &submit); +} + +static inline void vn_call_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBias(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetDepthBias_reply(&submit.reply, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetDepthBias(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBias(vn_instance, 0, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, &submit); +} + +static inline void vn_call_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetBlendConstants(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, blendConstants, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetBlendConstants_reply(&submit.reply, commandBuffer, blendConstants); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetBlendConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetBlendConstants(vn_instance, 0, commandBuffer, blendConstants, &submit); +} + +static inline void vn_call_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBounds(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, minDepthBounds, maxDepthBounds, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetDepthBounds_reply(&submit.reply, commandBuffer, minDepthBounds, maxDepthBounds); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetDepthBounds(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDepthBounds(vn_instance, 0, commandBuffer, minDepthBounds, maxDepthBounds, &submit); +} + +static inline void vn_call_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilCompareMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, compareMask, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetStencilCompareMask_reply(&submit.reply, commandBuffer, faceMask, compareMask); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetStencilCompareMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilCompareMask(vn_instance, 0, commandBuffer, faceMask, compareMask, &submit); +} + +static inline void vn_call_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilWriteMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, writeMask, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetStencilWriteMask_reply(&submit.reply, commandBuffer, faceMask, writeMask); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetStencilWriteMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilWriteMask(vn_instance, 0, commandBuffer, faceMask, writeMask, &submit); +} + +static inline void vn_call_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilReference(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, faceMask, reference, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetStencilReference_reply(&submit.reply, commandBuffer, faceMask, reference); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetStencilReference(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetStencilReference(vn_instance, 0, commandBuffer, faceMask, reference, &submit); +} + +static inline void vn_call_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBindDescriptorSets_reply(&submit.reply, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBindDescriptorSets(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindDescriptorSets(vn_instance, 0, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, &submit); +} + +static inline void vn_call_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindIndexBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, indexType, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBindIndexBuffer_reply(&submit.reply, commandBuffer, buffer, offset, indexType); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBindIndexBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindIndexBuffer(vn_instance, 0, commandBuffer, buffer, offset, indexType, &submit); +} + +static inline void vn_call_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindVertexBuffers(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBindVertexBuffers_reply(&submit.reply, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBindVertexBuffers(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindVertexBuffers(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, &submit); +} + +static inline void vn_call_vkCmdDraw(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDraw(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDraw_reply(&submit.reply, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDraw(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDraw(vn_instance, 0, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, &submit); +} + +static inline void vn_call_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndexed(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDrawIndexed_reply(&submit.reply, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDrawIndexed(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndexed(vn_instance, 0, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, &submit); +} + +static inline void vn_call_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, drawCount, stride, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDrawIndirect_reply(&submit.reply, commandBuffer, buffer, offset, drawCount, stride); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDrawIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndirect(vn_instance, 0, commandBuffer, buffer, offset, drawCount, stride, &submit); +} + +static inline void vn_call_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndexedIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, drawCount, stride, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDrawIndexedIndirect_reply(&submit.reply, commandBuffer, buffer, offset, drawCount, stride); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDrawIndexedIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndexedIndirect(vn_instance, 0, commandBuffer, buffer, offset, drawCount, stride, &submit); +} + +static inline void vn_call_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDispatch(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, groupCountX, groupCountY, groupCountZ, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDispatch_reply(&submit.reply, commandBuffer, groupCountX, groupCountY, groupCountZ); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDispatch(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDispatch(vn_instance, 0, commandBuffer, groupCountX, groupCountY, groupCountZ, &submit); +} + +static inline void vn_call_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDispatchIndirect(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDispatchIndirect_reply(&submit.reply, commandBuffer, buffer, offset); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDispatchIndirect(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDispatchIndirect(vn_instance, 0, commandBuffer, buffer, offset, &submit); +} + +static inline void vn_call_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdCopyBuffer_reply(&submit.reply, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdCopyBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBuffer(vn_instance, 0, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, &submit); +} + +static inline void vn_call_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdCopyImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdCopyImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit); +} + +static inline void vn_call_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBlitImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBlitImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBlitImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBlitImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, &submit); +} + +static inline void vn_call_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBufferToImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdCopyBufferToImage_reply(&submit.reply, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdCopyBufferToImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyBufferToImage(vn_instance, 0, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, &submit); +} + +static inline void vn_call_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImageToBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdCopyImageToBuffer_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdCopyImageToBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyImageToBuffer(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, &submit); +} + +static inline void vn_call_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdUpdateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, dstBuffer, dstOffset, dataSize, pData, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdUpdateBuffer_reply(&submit.reply, commandBuffer, dstBuffer, dstOffset, dataSize, pData); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdUpdateBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdUpdateBuffer(vn_instance, 0, commandBuffer, dstBuffer, dstOffset, dataSize, pData, &submit); +} + +static inline void vn_call_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdFillBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, dstBuffer, dstOffset, size, data, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdFillBuffer_reply(&submit.reply, commandBuffer, dstBuffer, dstOffset, size, data); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdFillBuffer(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdFillBuffer(vn_instance, 0, commandBuffer, dstBuffer, dstOffset, size, data, &submit); +} + +static inline void vn_call_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdClearColorImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdClearColorImage_reply(&submit.reply, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdClearColorImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdClearColorImage(vn_instance, 0, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, &submit); +} + +static inline void vn_call_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdClearDepthStencilImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdClearDepthStencilImage_reply(&submit.reply, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdClearDepthStencilImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdClearDepthStencilImage(vn_instance, 0, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, &submit); +} + +static inline void vn_call_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdClearAttachments(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, attachmentCount, pAttachments, rectCount, pRects, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdClearAttachments_reply(&submit.reply, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdClearAttachments(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdClearAttachments(vn_instance, 0, commandBuffer, attachmentCount, pAttachments, rectCount, pRects, &submit); +} + +static inline void vn_call_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResolveImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdResolveImage_reply(&submit.reply, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdResolveImage(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResolveImage(vn_instance, 0, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, &submit); +} + +static inline void vn_call_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetEvent_reply(&submit.reply, commandBuffer, event, stageMask); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetEvent(vn_instance, 0, commandBuffer, event, stageMask, &submit); +} + +static inline void vn_call_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, event, stageMask, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdResetEvent_reply(&submit.reply, commandBuffer, event, stageMask); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdResetEvent(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResetEvent(vn_instance, 0, commandBuffer, event, stageMask, &submit); +} + +static inline void vn_call_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdWaitEvents(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdWaitEvents_reply(&submit.reply, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdWaitEvents(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdWaitEvents(vn_instance, 0, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit); +} + +static inline void vn_call_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdPipelineBarrier(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdPipelineBarrier_reply(&submit.reply, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdPipelineBarrier(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdPipelineBarrier(vn_instance, 0, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, &submit); +} + +static inline void vn_call_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginQuery(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, flags, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBeginQuery_reply(&submit.reply, commandBuffer, queryPool, query, flags); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBeginQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginQuery(vn_instance, 0, commandBuffer, queryPool, query, flags, &submit); +} + +static inline void vn_call_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndQuery(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdEndQuery_reply(&submit.reply, commandBuffer, queryPool, query); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdEndQuery(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndQuery(vn_instance, 0, commandBuffer, queryPool, query, &submit); +} + +static inline void vn_call_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, firstQuery, queryCount, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdResetQueryPool_reply(&submit.reply, commandBuffer, queryPool, firstQuery, queryCount); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdResetQueryPool(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdResetQueryPool(vn_instance, 0, commandBuffer, queryPool, firstQuery, queryCount, &submit); +} + +static inline void vn_call_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdWriteTimestamp(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pipelineStage, queryPool, query, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdWriteTimestamp_reply(&submit.reply, commandBuffer, pipelineStage, queryPool, query); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdWriteTimestamp(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdWriteTimestamp(vn_instance, 0, commandBuffer, pipelineStage, queryPool, query, &submit); +} + +static inline void vn_call_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdCopyQueryPoolResults_reply(&submit.reply, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdCopyQueryPoolResults(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdCopyQueryPoolResults(vn_instance, 0, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, &submit); +} + +static inline void vn_call_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdPushConstants(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, layout, stageFlags, offset, size, pValues, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdPushConstants_reply(&submit.reply, commandBuffer, layout, stageFlags, offset, size, pValues); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdPushConstants(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdPushConstants(vn_instance, 0, commandBuffer, layout, stageFlags, offset, size, pValues, &submit); +} + +static inline void vn_call_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderPassBegin, contents, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBeginRenderPass_reply(&submit.reply, commandBuffer, pRenderPassBegin, contents); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBeginRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginRenderPass(vn_instance, 0, commandBuffer, pRenderPassBegin, contents, &submit); +} + +static inline void vn_call_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdNextSubpass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, contents, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdNextSubpass_reply(&submit.reply, commandBuffer, contents); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdNextSubpass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdNextSubpass(vn_instance, 0, commandBuffer, contents, &submit); +} + +static inline void vn_call_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdEndRenderPass_reply(&submit.reply, commandBuffer); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdEndRenderPass(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndRenderPass(vn_instance, 0, commandBuffer, &submit); +} + +static inline void vn_call_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdExecuteCommands(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, commandBufferCount, pCommandBuffers, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdExecuteCommands_reply(&submit.reply, commandBuffer, commandBufferCount, pCommandBuffers); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdExecuteCommands(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdExecuteCommands(vn_instance, 0, commandBuffer, commandBufferCount, pCommandBuffers, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceFeatures2_reply(&submit.reply, physicalDevice, pFeatures); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, 0, physicalDevice, pFeatures, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceProperties2_reply(&submit.reply, physicalDevice, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, 0, physicalDevice, pProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(&submit.reply, physicalDevice, format, pFormatProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit); +} + +static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(&submit.reply, physicalDevice, pImageFormatInfo, pImageFormatProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(&submit.reply, physicalDevice, pMemoryProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, 0, physicalDevice, pMemoryProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(&submit.reply, physicalDevice, pFormatInfo, pPropertyCount, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit); +} + +static inline void vn_call_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkTrimCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit); + if (submit.reply_bo) { + vn_decode_vkTrimCommandPool_reply(&submit.reply, device, commandPool, flags); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkTrimCommandPool(vn_instance, 0, device, commandPool, flags, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(&submit.reply, physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(&submit.reply, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit); +} + +static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit); + if (submit.reply_bo) { + vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(&submit.reply, physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit); +} + +static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(&submit.reply, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit); +} + +static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit); + if (submit.reply_bo) { + vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(&submit.reply, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit); +} + +static inline VkResult vn_call_vkBindBufferMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindBufferMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkBindBufferMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkBindBufferMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindBufferMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit); +} + +static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkBindImageMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + struct vn_instance_submit_command submit; + vn_submit_vkBindImageMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit); +} + +static inline void vn_call_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDeviceMask(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, deviceMask, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdSetDeviceMask_reply(&submit.reply, commandBuffer, deviceMask); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdSetDeviceMask(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdSetDeviceMask(vn_instance, 0, commandBuffer, deviceMask, &submit); +} + +static inline void vn_call_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDispatchBase(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDispatchBase_reply(&submit.reply, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDispatchBase(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDispatchBase(vn_instance, 0, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, &submit); +} + +static inline VkResult vn_call_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateDescriptorUpdateTemplate_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit); +} + +static inline void vn_call_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorUpdateTemplate, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyDescriptorUpdateTemplate_reply(&submit.reply, device, descriptorUpdateTemplate, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, 0, device, descriptorUpdateTemplate, pAllocator, &submit); +} + +static inline void vn_call_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit); + if (submit.reply_bo) { + vn_decode_vkGetBufferMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit); +} + +static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit); + if (submit.reply_bo) { + vn_decode_vkGetImageMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit); +} + +static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); + if (submit.reply_bo) { + vn_decode_vkGetImageSparseMemoryRequirements2_reply(&submit.reply, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit); +} + +static inline VkResult vn_call_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateSamplerYcbcrConversion_reply(&submit.reply, device, pCreateInfo, pAllocator, pYcbcrConversion); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, 0, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit); +} + +static inline void vn_call_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, ycbcrConversion, pAllocator, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroySamplerYcbcrConversion_reply(&submit.reply, device, ycbcrConversion, pAllocator); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, 0, device, ycbcrConversion, pAllocator, &submit); +} + +static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit); + if (submit.reply_bo) { + vn_decode_vkGetDeviceQueue2_reply(&submit.reply, device, pQueueInfo, pQueue); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit); +} + +static inline void vn_call_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pSupport, &submit); + if (submit.reply_bo) { + vn_decode_vkGetDescriptorSetLayoutSupport_reply(&submit.reply, device, pCreateInfo, pSupport); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, 0, device, pCreateInfo, pSupport, &submit); +} + +static inline VkResult vn_call_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkCreateRenderPass2_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateRenderPass2(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit); +} + +static inline void vn_call_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pRenderPassBegin, pSubpassBeginInfo, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBeginRenderPass2_reply(&submit.reply, commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBeginRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginRenderPass2(vn_instance, 0, commandBuffer, pRenderPassBegin, pSubpassBeginInfo, &submit); +} + +static inline void vn_call_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdNextSubpass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdNextSubpass2_reply(&submit.reply, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdNextSubpass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdNextSubpass2(vn_instance, 0, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, &submit); +} + +static inline void vn_call_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, pSubpassEndInfo, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdEndRenderPass2_reply(&submit.reply, commandBuffer, pSubpassEndInfo); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdEndRenderPass2(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndRenderPass2(vn_instance, 0, commandBuffer, pSubpassEndInfo, &submit); +} + +static inline VkResult vn_call_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetSemaphoreCounterValue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pValue, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(&submit.reply, device, semaphore, pValue); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetSemaphoreCounterValue(vn_instance, 0, device, semaphore, pValue, &submit); +} + +static inline VkResult vn_call_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkWaitSemaphores(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pWaitInfo, timeout, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkWaitSemaphores_reply(&submit.reply, device, pWaitInfo, timeout); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + struct vn_instance_submit_command submit; + vn_submit_vkWaitSemaphores(vn_instance, 0, device, pWaitInfo, timeout, &submit); +} + +static inline VkResult vn_call_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSignalSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pSignalInfo, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkSignalSemaphore_reply(&submit.reply, device, pSignalInfo); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSignalSemaphore(vn_instance, 0, device, pSignalInfo, &submit); +} + +static inline void vn_call_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndirectCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDrawIndirectCount_reply(&submit.reply, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDrawIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndirectCount(vn_instance, 0, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit); +} + +static inline void vn_call_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndexedIndirectCount(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDrawIndexedIndirectCount_reply(&submit.reply, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDrawIndexedIndirectCount(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndexedIndirectCount(vn_instance, 0, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, &submit); +} + +static inline void vn_call_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindTransformFeedbackBuffersEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBindTransformFeedbackBuffersEXT_reply(&submit.reply, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBindTransformFeedbackBuffersEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBindTransformFeedbackBuffersEXT(vn_instance, 0, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, &submit); +} + +static inline void vn_call_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginTransformFeedbackEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBeginTransformFeedbackEXT_reply(&submit.reply, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBeginTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginTransformFeedbackEXT(vn_instance, 0, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit); +} + +static inline void vn_call_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndTransformFeedbackEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdEndTransformFeedbackEXT_reply(&submit.reply, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdEndTransformFeedbackEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndTransformFeedbackEXT(vn_instance, 0, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, &submit); +} + +static inline void vn_call_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginQueryIndexedEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, flags, index, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdBeginQueryIndexedEXT_reply(&submit.reply, commandBuffer, queryPool, query, flags, index); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdBeginQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdBeginQueryIndexedEXT(vn_instance, 0, commandBuffer, queryPool, query, flags, index, &submit); +} + +static inline void vn_call_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndQueryIndexedEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, queryPool, query, index, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdEndQueryIndexedEXT_reply(&submit.reply, commandBuffer, queryPool, query, index); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdEndQueryIndexedEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdEndQueryIndexedEXT(vn_instance, 0, commandBuffer, queryPool, query, index, &submit); +} + +static inline void vn_call_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit); + if (submit.reply_bo) { + vn_decode_vkCmdDrawIndirectByteCountEXT_reply(&submit.reply, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCmdDrawIndirectByteCountEXT(struct vn_instance *vn_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCmdDrawIndirectByteCountEXT(vn_instance, 0, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, &submit); +} + +static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit); + if (submit.reply_bo) { + const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(&submit.reply, device, image, pProperties); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, 0, device, image, pProperties, &submit); +} + +static inline uint64_t vn_call_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit); + if (submit.reply_bo) { + const uint64_t ret = vn_decode_vkGetBufferOpaqueCaptureAddress_reply(&submit.reply, device, pInfo); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, 0, device, pInfo, &submit); +} + +static inline VkDeviceAddress vn_call_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferDeviceAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit); + if (submit.reply_bo) { + const VkDeviceAddress ret = vn_decode_vkGetBufferDeviceAddress_reply(&submit.reply, device, pInfo); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetBufferDeviceAddress(vn_instance, 0, device, pInfo, &submit); +} + +static inline uint64_t vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit); + if (submit.reply_bo) { + const uint64_t ret = vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(&submit.reply, device, pInfo); + vn_renderer_bo_unref(submit.reply_bo); + return ret; + } else { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } +} + +static inline void vn_async_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, 0, device, pInfo, &submit); +} + +static inline void vn_call_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSetReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pStream, &submit); + if (submit.reply_bo) { + vn_decode_vkSetReplyCommandStreamMESA_reply(&submit.reply, pStream); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSetReplyCommandStreamMESA(vn_instance, 0, pStream, &submit); +} + +static inline void vn_call_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, position, &submit); + if (submit.reply_bo) { + vn_decode_vkSeekReplyCommandStreamMESA_reply(&submit.reply, position); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position) +{ + struct vn_instance_submit_command submit; + vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, 0, position, &submit); +} + +static inline void vn_call_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkExecuteCommandStreamsMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit); + if (submit.reply_bo) { + vn_decode_vkExecuteCommandStreamsMESA_reply(&submit.reply, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkExecuteCommandStreamsMESA(vn_instance, 0, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit); +} + +static inline void vn_call_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, pCreateInfo, &submit); + if (submit.reply_bo) { + vn_decode_vkCreateRingMESA_reply(&submit.reply, ring, pCreateInfo); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo) +{ + struct vn_instance_submit_command submit; + vn_submit_vkCreateRingMESA(vn_instance, 0, ring, pCreateInfo, &submit); +} + +static inline void vn_call_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, &submit); + if (submit.reply_bo) { + vn_decode_vkDestroyRingMESA_reply(&submit.reply, ring); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring) +{ + struct vn_instance_submit_command submit; + vn_submit_vkDestroyRingMESA(vn_instance, 0, ring, &submit); +} + +static inline void vn_call_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkNotifyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, flags, &submit); + if (submit.reply_bo) { + vn_decode_vkNotifyRingMESA_reply(&submit.reply, ring, seqno, flags); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags) +{ + struct vn_instance_submit_command submit; + vn_submit_vkNotifyRingMESA(vn_instance, 0, ring, seqno, flags, &submit); +} + +static inline void vn_call_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value) +{ + struct vn_instance_submit_command submit; + vn_submit_vkWriteRingExtraMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, offset, value, &submit); + if (submit.reply_bo) { + vn_decode_vkWriteRingExtraMESA_reply(&submit.reply, ring, offset, value); + vn_renderer_bo_unref(submit.reply_bo); + } +} + +static inline void vn_async_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value) +{ + struct vn_instance_submit_command submit; + vn_submit_vkWriteRingExtraMESA(vn_instance, 0, ring, offset, value, &submit); +} + +#endif /* VN_PROTOCOL_DRIVER_CALLS_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_commands.h b/src/virtio/venus-protocol/vn_protocol_driver_commands.h new file mode 100644 index 00000000000..ff3d7d00b30 --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_commands.h @@ -0,0 +1,11871 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_COMMANDS_H +#define VN_PROTOCOL_DRIVER_COMMANDS_H + +#include "vn_protocol_driver_structs.h" + +/* + * These commands are not included + * + * vkGetDeviceProcAddr + * vkGetInstanceProcAddr + * vkMapMemory + * vkUpdateDescriptorSetWithTemplate + */ + +static inline size_t vn_sizeof_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkInstanceCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pInstance); + if (pInstance) + cmd_size += vn_sizeof_VkInstance(pInstance); + + return cmd_size; +} + +static inline void vn_encode_vkCreateInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkInstanceCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pInstance)) + vn_encode_VkInstance(enc, pInstance); +} + +static inline size_t vn_sizeof_vkCreateInstance_reply(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pInstance); + if (pInstance) + cmd_size += vn_sizeof_VkInstance(pInstance); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateInstance_reply(struct vn_cs_decoder *dec, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateInstance_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkInstance(dec, pInstance); + } else { + pInstance = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkInstance(&instance); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkInstance(enc, &instance); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyInstance_reply(VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip instance */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyInstance_reply(struct vn_cs_decoder *dec, VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyInstance_EXT); + + /* skip instance */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkInstance(&instance); + cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount); + if (pPhysicalDeviceCount) + cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount); + if (pPhysicalDevices) { + cmd_size += vn_sizeof_array_size(*pPhysicalDeviceCount); + for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) + cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkInstance(enc, &instance); + if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount)) + vn_encode_uint32_t(enc, pPhysicalDeviceCount); + if (pPhysicalDevices) { + vn_encode_array_size(enc, *pPhysicalDeviceCount); + for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) + vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip instance */ + cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount); + if (pPhysicalDeviceCount) + cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount); + if (pPhysicalDevices) { + cmd_size += vn_sizeof_array_size(*pPhysicalDeviceCount); + for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) + cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip instance */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPhysicalDeviceCount); + } else { + pPhysicalDeviceCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPhysicalDeviceCount); + for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) + vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]); + } else { + vn_decode_array_size(dec, 0); + pPhysicalDevices = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pProperties); + if (pProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pProperties)) + vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pProperties); + if (pProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPhysicalDeviceProperties(dec, pProperties); + } else { + pProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount); + if (pQueueFamilyPropertyCount) + cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount); + if (pQueueFamilyProperties) { + cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount)) + vn_encode_uint32_t(enc, pQueueFamilyPropertyCount); + if (pQueueFamilyProperties) { + vn_encode_array_size(enc, *pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount); + if (pQueueFamilyPropertyCount) + cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount); + if (pQueueFamilyProperties) { + cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pQueueFamilyPropertyCount); + } else { + pQueueFamilyPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pQueueFamilyProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pMemoryProperties); + if (pMemoryProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pMemoryProperties)) + vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pMemoryProperties); + if (pMemoryProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties); + } else { + pMemoryProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pFeatures); + if (pFeatures) + cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pFeatures)) + vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pFeatures); + if (pFeatures) + cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures); + } else { + pFeatures = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_VkFormat(&format); + cmd_size += vn_sizeof_simple_pointer(pFormatProperties); + if (pFormatProperties) + cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + vn_encode_VkFormat(enc, &format); + if (vn_encode_simple_pointer(enc, pFormatProperties)) + vn_encode_VkFormatProperties_partial(enc, pFormatProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip format */ + cmd_size += vn_sizeof_simple_pointer(pFormatProperties); + if (pFormatProperties) + cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT); + + /* skip physicalDevice */ + /* skip format */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkFormatProperties(dec, pFormatProperties); + } else { + pFormatProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_VkFormat(&format); + cmd_size += vn_sizeof_VkImageType(&type); + cmd_size += vn_sizeof_VkImageTiling(&tiling); + cmd_size += vn_sizeof_VkFlags(&usage); + cmd_size += vn_sizeof_VkFlags(&flags); + cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties); + if (pImageFormatProperties) + cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + vn_encode_VkFormat(enc, &format); + vn_encode_VkImageType(enc, &type); + vn_encode_VkImageTiling(enc, &tiling); + vn_encode_VkFlags(enc, &usage); + vn_encode_VkFlags(enc, &flags); + if (vn_encode_simple_pointer(enc, pImageFormatProperties)) + vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip physicalDevice */ + /* skip format */ + /* skip type */ + /* skip tiling */ + /* skip usage */ + /* skip flags */ + cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties); + if (pImageFormatProperties) + cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties); + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip physicalDevice */ + /* skip format */ + /* skip type */ + /* skip tiling */ + /* skip usage */ + /* skip flags */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkImageFormatProperties(dec, pImageFormatProperties); + } else { + pImageFormatProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pDevice); + if (pDevice) + cmd_size += vn_sizeof_VkDevice(pDevice); + + return cmd_size; +} + +static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkDeviceCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pDevice)) + vn_encode_VkDevice(enc, pDevice); +} + +static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip physicalDevice */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pDevice); + if (pDevice) + cmd_size += vn_sizeof_VkDevice(pDevice); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip physicalDevice */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDevice(dec, pDevice); + } else { + pDevice = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT); + + /* skip device */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkEnumerateInstanceVersion(uint32_t* pApiVersion) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_simple_pointer(pApiVersion); /* out */ + + return cmd_size; +} + +static inline void vn_encode_vkEnumerateInstanceVersion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_simple_pointer(enc, pApiVersion); /* out */ +} + +static inline size_t vn_sizeof_vkEnumerateInstanceVersion_reply(uint32_t* pApiVersion) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + cmd_size += vn_sizeof_simple_pointer(pApiVersion); + if (pApiVersion) + cmd_size += vn_sizeof_uint32_t(pApiVersion); + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumerateInstanceVersion_reply(struct vn_cs_decoder *dec, uint32_t* pApiVersion) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pApiVersion); + } else { + pApiVersion = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkEnumerateInstanceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + if (vn_encode_simple_pointer(enc, pPropertyCount)) + vn_encode_uint32_t(enc, pPropertyCount); + if (pProperties) { + vn_encode_array_size(enc, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_encode_VkLayerProperties_partial(enc, &pProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties_reply(uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumerateInstanceLayerProperties_reply(struct vn_cs_decoder *dec, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPropertyCount); + } else { + pPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_decode_VkLayerProperties(dec, &pProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + if (pLayerName) { + const size_t string_size = strlen(pLayerName) + 1; + cmd_size += vn_sizeof_array_size(string_size); + cmd_size += vn_sizeof_blob_array(pLayerName, string_size); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkEnumerateInstanceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + if (pLayerName) { + const size_t string_size = strlen(pLayerName) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, pLayerName, string_size); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, pPropertyCount)) + vn_encode_uint32_t(enc, pPropertyCount); + if (pProperties) { + vn_encode_array_size(enc, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip pLayerName */ + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumerateInstanceExtensionProperties_reply(struct vn_cs_decoder *dec, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip pLayerName */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPropertyCount); + } else { + pPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_decode_VkExtensionProperties(dec, &pProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pPropertyCount)) + vn_encode_uint32_t(enc, pPropertyCount); + if (pProperties) { + vn_encode_array_size(enc, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_encode_VkLayerProperties_partial(enc, &pProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPropertyCount); + } else { + pPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_decode_VkLayerProperties(dec, &pProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + if (pLayerName) { + const size_t string_size = strlen(pLayerName) + 1; + cmd_size += vn_sizeof_array_size(string_size); + cmd_size += vn_sizeof_blob_array(pLayerName, string_size); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (pLayerName) { + const size_t string_size = strlen(pLayerName) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, pLayerName, string_size); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, pPropertyCount)) + vn_encode_uint32_t(enc, pPropertyCount); + if (pProperties) { + vn_encode_array_size(enc, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip physicalDevice */ + /* skip pLayerName */ + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip physicalDevice */ + /* skip pLayerName */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPropertyCount); + } else { + pPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_decode_VkExtensionProperties(dec, &pProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex); + cmd_size += vn_sizeof_uint32_t(&queueIndex); + cmd_size += vn_sizeof_simple_pointer(pQueue); + if (pQueue) + cmd_size += vn_sizeof_VkQueue(pQueue); + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &queueFamilyIndex); + vn_encode_uint32_t(enc, &queueIndex); + if (vn_encode_simple_pointer(enc, pQueue)) + vn_encode_VkQueue(enc, pQueue); +} + +static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip queueFamilyIndex */ + /* skip queueIndex */ + cmd_size += vn_sizeof_simple_pointer(pQueue); + if (pQueue) + cmd_size += vn_sizeof_VkQueue(pQueue); + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT); + + /* skip device */ + /* skip queueFamilyIndex */ + /* skip queueIndex */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkQueue(dec, pQueue); + } else { + pQueue = NULL; + } +} + +static inline size_t vn_sizeof_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkQueue(&queue); + cmd_size += vn_sizeof_uint32_t(&submitCount); + if (pSubmits) { + cmd_size += vn_sizeof_array_size(submitCount); + for (uint32_t i = 0; i < submitCount; i++) + cmd_size += vn_sizeof_VkSubmitInfo(&pSubmits[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkFence(&fence); + + return cmd_size; +} + +static inline void vn_encode_vkQueueSubmit(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkQueue(enc, &queue); + vn_encode_uint32_t(enc, &submitCount); + if (pSubmits) { + vn_encode_array_size(enc, submitCount); + for (uint32_t i = 0; i < submitCount; i++) + vn_encode_VkSubmitInfo(enc, &pSubmits[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFence(enc, &fence); +} + +static inline size_t vn_sizeof_vkQueueSubmit_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip queue */ + /* skip submitCount */ + /* skip pSubmits */ + /* skip fence */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkQueueSubmit_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip queue */ + /* skip submitCount */ + /* skip pSubmits */ + /* skip fence */ + + return ret; +} + +static inline size_t vn_sizeof_vkQueueWaitIdle(VkQueue queue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkQueue(&queue); + + return cmd_size; +} + +static inline void vn_encode_vkQueueWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkQueue(enc, &queue); +} + +static inline size_t vn_sizeof_vkQueueWaitIdle_reply(VkQueue queue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueWaitIdle_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip queue */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkQueueWaitIdle_reply(struct vn_cs_decoder *dec, VkQueue queue) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkQueueWaitIdle_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip queue */ + + return ret; +} + +static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + + return cmd_size; +} + +static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); +} + +static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + + return ret; +} + +static inline size_t vn_sizeof_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pAllocateInfo); + if (pAllocateInfo) + cmd_size += vn_sizeof_VkMemoryAllocateInfo(pAllocateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pMemory); + if (pMemory) + cmd_size += vn_sizeof_VkDeviceMemory(pMemory); + + return cmd_size; +} + +static inline void vn_encode_vkAllocateMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pAllocateInfo)) + vn_encode_VkMemoryAllocateInfo(enc, pAllocateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pMemory)) + vn_encode_VkDeviceMemory(enc, pMemory); +} + +static inline size_t vn_sizeof_vkAllocateMemory_reply(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateMemory_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pAllocateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pMemory); + if (pMemory) + cmd_size += vn_sizeof_VkDeviceMemory(pMemory); + + return cmd_size; +} + +static inline VkResult vn_decode_vkAllocateMemory_reply(struct vn_cs_decoder *dec, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkAllocateMemory_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pAllocateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDeviceMemory(dec, pMemory); + } else { + pMemory = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDeviceMemory(&memory); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkFreeMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDeviceMemory(enc, &memory); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkFreeMemory_reply(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeMemory_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip memory */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkFreeMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkFreeMemory_EXT); + + /* skip device */ + /* skip memory */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDeviceMemory(&memory); + + return cmd_size; +} + +static inline void vn_encode_vkUnmapMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDeviceMemory(enc, &memory); +} + +static inline size_t vn_sizeof_vkUnmapMemory_reply(VkDevice device, VkDeviceMemory memory) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUnmapMemory_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip memory */ + + return cmd_size; +} + +static inline void vn_decode_vkUnmapMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkUnmapMemory_EXT); + + /* skip device */ + /* skip memory */ +} + +static inline size_t vn_sizeof_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&memoryRangeCount); + if (pMemoryRanges) { + cmd_size += vn_sizeof_array_size(memoryRangeCount); + for (uint32_t i = 0; i < memoryRangeCount; i++) + cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkFlushMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &memoryRangeCount); + if (pMemoryRanges) { + vn_encode_array_size(enc, memoryRangeCount); + for (uint32_t i = 0; i < memoryRangeCount; i++) + vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkFlushMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip memoryRangeCount */ + /* skip pMemoryRanges */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkFlushMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip memoryRangeCount */ + /* skip pMemoryRanges */ + + return ret; +} + +static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&memoryRangeCount); + if (pMemoryRanges) { + cmd_size += vn_sizeof_array_size(memoryRangeCount); + for (uint32_t i = 0; i < memoryRangeCount; i++) + cmd_size += vn_sizeof_VkMappedMemoryRange(&pMemoryRanges[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkInvalidateMappedMemoryRanges(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &memoryRangeCount); + if (pMemoryRanges) { + vn_encode_array_size(enc, memoryRangeCount); + for (uint32_t i = 0; i < memoryRangeCount; i++) + vn_encode_VkMappedMemoryRange(enc, &pMemoryRanges[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkInvalidateMappedMemoryRanges_reply(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip memoryRangeCount */ + /* skip pMemoryRanges */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkInvalidateMappedMemoryRanges_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip memoryRangeCount */ + /* skip pMemoryRanges */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDeviceMemory(&memory); + cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes); /* out */ + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceMemoryCommitment(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDeviceMemory(enc, &memory); + vn_encode_simple_pointer(enc, pCommittedMemoryInBytes); /* out */ +} + +static inline size_t vn_sizeof_vkGetDeviceMemoryCommitment_reply(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip memory */ + cmd_size += vn_sizeof_simple_pointer(pCommittedMemoryInBytes); + if (pCommittedMemoryInBytes) + cmd_size += vn_sizeof_VkDeviceSize(pCommittedMemoryInBytes); + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceMemoryCommitment_reply(struct vn_cs_decoder *dec, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT); + + /* skip device */ + /* skip memory */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDeviceSize(dec, pCommittedMemoryInBytes); + } else { + pCommittedMemoryInBytes = NULL; + } +} + +static inline size_t vn_sizeof_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_encode_vkGetBufferMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkBuffer(enc, &buffer); + if (vn_encode_simple_pointer(enc, pMemoryRequirements)) + vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements); +} + +static inline size_t vn_sizeof_vkGetBufferMemoryRequirements_reply(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip buffer */ + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_decode_vkGetBufferMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT); + + /* skip device */ + /* skip buffer */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkMemoryRequirements(dec, pMemoryRequirements); + } else { + pMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceMemory(&memory); + cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset); + + return cmd_size; +} + +static inline void vn_encode_vkBindBufferMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceMemory(enc, &memory); + vn_encode_VkDeviceSize(enc, &memoryOffset); +} + +static inline size_t vn_sizeof_vkBindBufferMemory_reply(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip buffer */ + /* skip memory */ + /* skip memoryOffset */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkBindBufferMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkBindBufferMemory_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip buffer */ + /* skip memory */ + /* skip memoryOffset */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImage(enc, &image); + if (vn_encode_simple_pointer(enc, pMemoryRequirements)) + vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements); +} + +static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip image */ + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT); + + /* skip device */ + /* skip image */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkMemoryRequirements(dec, pMemoryRequirements); + } else { + pMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_VkDeviceMemory(&memory); + cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset); + + return cmd_size; +} + +static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImage(enc, &image); + vn_encode_VkDeviceMemory(enc, &memory); + vn_encode_VkDeviceSize(enc, &memoryOffset); +} + +static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip image */ + /* skip memory */ + /* skip memoryOffset */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip image */ + /* skip memory */ + /* skip memoryOffset */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirementCount) + cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImage(enc, &image); + if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount)) + vn_encode_uint32_t(enc, pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + vn_encode_array_size(enc, *pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip image */ + cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirementCount) + cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT); + + /* skip device */ + /* skip image */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pSparseMemoryRequirementCount); + } else { + pSparseMemoryRequirementCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]); + } else { + vn_decode_array_size(dec, 0); + pSparseMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_VkFormat(&format); + cmd_size += vn_sizeof_VkImageType(&type); + cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples); + cmd_size += vn_sizeof_VkFlags(&usage); + cmd_size += vn_sizeof_VkImageTiling(&tiling); + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + vn_encode_VkFormat(enc, &format); + vn_encode_VkImageType(enc, &type); + vn_encode_VkSampleCountFlagBits(enc, &samples); + vn_encode_VkFlags(enc, &usage); + vn_encode_VkImageTiling(enc, &tiling); + if (vn_encode_simple_pointer(enc, pPropertyCount)) + vn_encode_uint32_t(enc, pPropertyCount); + if (pProperties) { + vn_encode_array_size(enc, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip format */ + /* skip type */ + /* skip samples */ + /* skip usage */ + /* skip tiling */ + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT); + + /* skip physicalDevice */ + /* skip format */ + /* skip type */ + /* skip samples */ + /* skip usage */ + /* skip tiling */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPropertyCount); + } else { + pPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkQueue(&queue); + cmd_size += vn_sizeof_uint32_t(&bindInfoCount); + if (pBindInfo) { + cmd_size += vn_sizeof_array_size(bindInfoCount); + for (uint32_t i = 0; i < bindInfoCount; i++) + cmd_size += vn_sizeof_VkBindSparseInfo(&pBindInfo[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkFence(&fence); + + return cmd_size; +} + +static inline void vn_encode_vkQueueBindSparse(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkQueue(enc, &queue); + vn_encode_uint32_t(enc, &bindInfoCount); + if (pBindInfo) { + vn_encode_array_size(enc, bindInfoCount); + for (uint32_t i = 0; i < bindInfoCount; i++) + vn_encode_VkBindSparseInfo(enc, &pBindInfo[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFence(enc, &fence); +} + +static inline size_t vn_sizeof_vkQueueBindSparse_reply(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueBindSparse_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip queue */ + /* skip bindInfoCount */ + /* skip pBindInfo */ + /* skip fence */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkQueueBindSparse_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkQueueBindSparse_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip queue */ + /* skip bindInfoCount */ + /* skip pBindInfo */ + /* skip fence */ + + return ret; +} + +static inline size_t vn_sizeof_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkFenceCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pFence); + if (pFence) + cmd_size += vn_sizeof_VkFence(pFence); + + return cmd_size; +} + +static inline void vn_encode_vkCreateFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkFenceCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pFence)) + vn_encode_VkFence(enc, pFence); +} + +static inline size_t vn_sizeof_vkCreateFence_reply(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pFence); + if (pFence) + cmd_size += vn_sizeof_VkFence(pFence); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateFence_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateFence_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkFence(dec, pFence); + } else { + pFence = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkFence(&fence); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkFence(enc, &fence); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyFence_reply(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip fence */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyFence_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyFence_EXT); + + /* skip device */ + /* skip fence */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&fenceCount); + if (pFences) { + cmd_size += vn_sizeof_array_size(fenceCount); + for (uint32_t i = 0; i < fenceCount; i++) + cmd_size += vn_sizeof_VkFence(&pFences[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkResetFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &fenceCount); + if (pFences) { + vn_encode_array_size(enc, fenceCount); + for (uint32_t i = 0; i < fenceCount; i++) + vn_encode_VkFence(enc, &pFences[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkResetFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip fenceCount */ + /* skip pFences */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkResetFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkResetFences_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip fenceCount */ + /* skip pFences */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetFenceStatus(VkDevice device, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkFence(&fence); + + return cmd_size; +} + +static inline void vn_encode_vkGetFenceStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkFence(enc, &fence); +} + +static inline size_t vn_sizeof_vkGetFenceStatus_reply(VkDevice device, VkFence fence) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip fence */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetFenceStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetFenceStatus_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip fence */ + + return ret; +} + +static inline size_t vn_sizeof_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&fenceCount); + if (pFences) { + cmd_size += vn_sizeof_array_size(fenceCount); + for (uint32_t i = 0; i < fenceCount; i++) + cmd_size += vn_sizeof_VkFence(&pFences[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkBool32(&waitAll); + cmd_size += vn_sizeof_uint64_t(&timeout); + + return cmd_size; +} + +static inline void vn_encode_vkWaitForFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &fenceCount); + if (pFences) { + vn_encode_array_size(enc, fenceCount); + for (uint32_t i = 0; i < fenceCount; i++) + vn_encode_VkFence(enc, &pFences[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkBool32(enc, &waitAll); + vn_encode_uint64_t(enc, &timeout); +} + +static inline size_t vn_sizeof_vkWaitForFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip fenceCount */ + /* skip pFences */ + /* skip waitAll */ + /* skip timeout */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkWaitForFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkWaitForFences_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip fenceCount */ + /* skip pFences */ + /* skip waitAll */ + /* skip timeout */ + + return ret; +} + +static inline size_t vn_sizeof_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkSemaphoreCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pSemaphore); + if (pSemaphore) + cmd_size += vn_sizeof_VkSemaphore(pSemaphore); + + return cmd_size; +} + +static inline void vn_encode_vkCreateSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkSemaphoreCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pSemaphore)) + vn_encode_VkSemaphore(enc, pSemaphore); +} + +static inline size_t vn_sizeof_vkCreateSemaphore_reply(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pSemaphore); + if (pSemaphore) + cmd_size += vn_sizeof_VkSemaphore(pSemaphore); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateSemaphore_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkSemaphore(dec, pSemaphore); + } else { + pSemaphore = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkSemaphore(&semaphore); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroySemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkSemaphore(enc, &semaphore); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroySemaphore_reply(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip semaphore */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroySemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroySemaphore_EXT); + + /* skip device */ + /* skip semaphore */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkEventCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pEvent); + if (pEvent) + cmd_size += vn_sizeof_VkEvent(pEvent); + + return cmd_size; +} + +static inline void vn_encode_vkCreateEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkEventCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pEvent)) + vn_encode_VkEvent(enc, pEvent); +} + +static inline size_t vn_sizeof_vkCreateEvent_reply(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pEvent); + if (pEvent) + cmd_size += vn_sizeof_VkEvent(pEvent); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateEvent_reply(struct vn_cs_decoder *dec, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateEvent_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkEvent(dec, pEvent); + } else { + pEvent = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkEvent(&event); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkEvent(enc, &event); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyEvent_reply(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip event */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyEvent_EXT); + + /* skip device */ + /* skip event */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetEventStatus(VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkEvent(&event); + + return cmd_size; +} + +static inline void vn_encode_vkGetEventStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkEvent(enc, &event); +} + +static inline size_t vn_sizeof_vkGetEventStatus_reply(VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip event */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetEventStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetEventStatus_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip event */ + + return ret; +} + +static inline size_t vn_sizeof_vkSetEvent(VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkEvent(&event); + + return cmd_size; +} + +static inline void vn_encode_vkSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkEvent(enc, &event); +} + +static inline size_t vn_sizeof_vkSetEvent_reply(VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip event */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkSetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkSetEvent_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip event */ + + return ret; +} + +static inline size_t vn_sizeof_vkResetEvent(VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkEvent(&event); + + return cmd_size; +} + +static inline void vn_encode_vkResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkEvent(enc, &event); +} + +static inline size_t vn_sizeof_vkResetEvent_reply(VkDevice device, VkEvent event) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip event */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkResetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkResetEvent_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip event */ + + return ret; +} + +static inline size_t vn_sizeof_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkQueryPoolCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pQueryPool); + if (pQueryPool) + cmd_size += vn_sizeof_VkQueryPool(pQueryPool); + + return cmd_size; +} + +static inline void vn_encode_vkCreateQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkQueryPoolCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pQueryPool)) + vn_encode_VkQueryPool(enc, pQueryPool); +} + +static inline size_t vn_sizeof_vkCreateQueryPool_reply(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pQueryPool); + if (pQueryPool) + cmd_size += vn_sizeof_VkQueryPool(pQueryPool); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateQueryPool_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkQueryPool(dec, pQueryPool); + } else { + pQueryPool = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkQueryPool(enc, &queryPool); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyQueryPool_reply(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip queryPool */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyQueryPool_EXT); + + /* skip device */ + /* skip queryPool */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&firstQuery); + cmd_size += vn_sizeof_uint32_t(&queryCount); + cmd_size += vn_sizeof_size_t(&dataSize); + cmd_size += vn_sizeof_simple_pointer(pData); /* out */ + cmd_size += vn_sizeof_VkDeviceSize(&stride); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkGetQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &firstQuery); + vn_encode_uint32_t(enc, &queryCount); + vn_encode_size_t(enc, &dataSize); + vn_encode_array_size(enc, pData ? dataSize : 0); /* out */ + vn_encode_VkDeviceSize(enc, &stride); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkGetQueryPoolResults_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ + /* skip dataSize */ + if (pData) { + cmd_size += vn_sizeof_array_size(dataSize); + cmd_size += vn_sizeof_blob_array(pData, dataSize); + } else { + cmd_size += vn_sizeof_array_size(0); + } + /* skip stride */ + /* skip flags */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetQueryPoolResults_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ + /* skip dataSize */ + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, dataSize); + vn_decode_blob_array(dec, pData, array_size); + } else { + vn_decode_array_size(dec, 0); + pData = NULL; + } + /* skip stride */ + /* skip flags */ + + return ret; +} + +static inline size_t vn_sizeof_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&firstQuery); + cmd_size += vn_sizeof_uint32_t(&queryCount); + + return cmd_size; +} + +static inline void vn_encode_vkResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &firstQuery); + vn_encode_uint32_t(enc, &queryCount); +} + +static inline size_t vn_sizeof_vkResetQueryPool_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ + + return cmd_size; +} + +static inline void vn_decode_vkResetQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkResetQueryPool_EXT); + + /* skip device */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ +} + +static inline size_t vn_sizeof_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkBufferCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pBuffer); + if (pBuffer) + cmd_size += vn_sizeof_VkBuffer(pBuffer); + + return cmd_size; +} + +static inline void vn_encode_vkCreateBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkBufferCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pBuffer)) + vn_encode_VkBuffer(enc, pBuffer); +} + +static inline size_t vn_sizeof_vkCreateBuffer_reply(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pBuffer); + if (pBuffer) + cmd_size += vn_sizeof_VkBuffer(pBuffer); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateBuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateBuffer_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkBuffer(dec, pBuffer); + } else { + pBuffer = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkBuffer(enc, &buffer); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyBuffer_reply(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip buffer */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyBuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyBuffer_EXT); + + /* skip device */ + /* skip buffer */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkBufferViewCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pView); + if (pView) + cmd_size += vn_sizeof_VkBufferView(pView); + + return cmd_size; +} + +static inline void vn_encode_vkCreateBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkBufferViewCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pView)) + vn_encode_VkBufferView(enc, pView); +} + +static inline size_t vn_sizeof_vkCreateBufferView_reply(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pView); + if (pView) + cmd_size += vn_sizeof_VkBufferView(pView); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateBufferView_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkBufferView(dec, pView); + } else { + pView = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkBufferView(&bufferView); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkBufferView(enc, &bufferView); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyBufferView_reply(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip bufferView */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyBufferView_EXT); + + /* skip device */ + /* skip bufferView */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pImage); + if (pImage) + cmd_size += vn_sizeof_VkImage(pImage); + + return cmd_size; +} + +static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkImageCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pImage)) + vn_encode_VkImage(enc, pImage); +} + +static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pImage); + if (pImage) + cmd_size += vn_sizeof_VkImage(pImage); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkImage(dec, pImage); + } else { + pImage = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImage(enc, &image); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip image */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT); + + /* skip device */ + /* skip image */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_simple_pointer(pSubresource); + if (pSubresource) + cmd_size += vn_sizeof_VkImageSubresource(pSubresource); + cmd_size += vn_sizeof_simple_pointer(pLayout); + if (pLayout) + cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout); + + return cmd_size; +} + +static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImage(enc, &image); + if (vn_encode_simple_pointer(enc, pSubresource)) + vn_encode_VkImageSubresource(enc, pSubresource); + if (vn_encode_simple_pointer(enc, pLayout)) + vn_encode_VkSubresourceLayout_partial(enc, pLayout); +} + +static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip image */ + /* skip pSubresource */ + cmd_size += vn_sizeof_simple_pointer(pLayout); + if (pLayout) + cmd_size += vn_sizeof_VkSubresourceLayout(pLayout); + + return cmd_size; +} + +static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT); + + /* skip device */ + /* skip image */ + /* skip pSubresource */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkSubresourceLayout(dec, pLayout); + } else { + pLayout = NULL; + } +} + +static inline size_t vn_sizeof_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkImageViewCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pView); + if (pView) + cmd_size += vn_sizeof_VkImageView(pView); + + return cmd_size; +} + +static inline void vn_encode_vkCreateImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkImageViewCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pView)) + vn_encode_VkImageView(enc, pView); +} + +static inline size_t vn_sizeof_vkCreateImageView_reply(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pView); + if (pView) + cmd_size += vn_sizeof_VkImageView(pView); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateImageView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateImageView_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkImageView(dec, pView); + } else { + pView = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImageView(&imageView); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImageView(enc, &imageView); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyImageView_reply(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip imageView */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyImageView_reply(struct vn_cs_decoder *dec, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyImageView_EXT); + + /* skip device */ + /* skip imageView */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkShaderModuleCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pShaderModule); + if (pShaderModule) + cmd_size += vn_sizeof_VkShaderModule(pShaderModule); + + return cmd_size; +} + +static inline void vn_encode_vkCreateShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkShaderModuleCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pShaderModule)) + vn_encode_VkShaderModule(enc, pShaderModule); +} + +static inline size_t vn_sizeof_vkCreateShaderModule_reply(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pShaderModule); + if (pShaderModule) + cmd_size += vn_sizeof_VkShaderModule(pShaderModule); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateShaderModule_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkShaderModule(dec, pShaderModule); + } else { + pShaderModule = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkShaderModule(&shaderModule); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkShaderModule(enc, &shaderModule); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyShaderModule_reply(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip shaderModule */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyShaderModule_EXT); + + /* skip device */ + /* skip shaderModule */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkPipelineCacheCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pPipelineCache); + if (pPipelineCache) + cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache); + + return cmd_size; +} + +static inline void vn_encode_vkCreatePipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkPipelineCacheCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pPipelineCache)) + vn_encode_VkPipelineCache(enc, pPipelineCache); +} + +static inline size_t vn_sizeof_vkCreatePipelineCache_reply(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pPipelineCache); + if (pPipelineCache) + cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreatePipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineCache_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPipelineCache(dec, pPipelineCache); + } else { + pPipelineCache = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyPipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipelineCache(enc, &pipelineCache); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyPipelineCache_reply(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pipelineCache */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyPipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT); + + /* skip device */ + /* skip pipelineCache */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache); + cmd_size += vn_sizeof_simple_pointer(pDataSize); + if (pDataSize) + cmd_size += vn_sizeof_size_t(pDataSize); + cmd_size += vn_sizeof_simple_pointer(pData); /* out */ + + return cmd_size; +} + +static inline void vn_encode_vkGetPipelineCacheData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipelineCache(enc, &pipelineCache); + if (vn_encode_simple_pointer(enc, pDataSize)) + vn_encode_size_t(enc, pDataSize); + vn_encode_array_size(enc, pData ? *pDataSize : 0); /* out */ +} + +static inline size_t vn_sizeof_vkGetPipelineCacheData_reply(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pipelineCache */ + cmd_size += vn_sizeof_simple_pointer(pDataSize); + if (pDataSize) + cmd_size += vn_sizeof_size_t(pDataSize); + if (pData) { + cmd_size += vn_sizeof_array_size(*pDataSize); + cmd_size += vn_sizeof_blob_array(pData, *pDataSize); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetPipelineCacheData_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pipelineCache */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_size_t(dec, pDataSize); + } else { + pDataSize = NULL; + } + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, *pDataSize); + vn_decode_blob_array(dec, pData, array_size); + } else { + vn_decode_array_size(dec, 0); + pData = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipelineCache(&dstCache); + cmd_size += vn_sizeof_uint32_t(&srcCacheCount); + if (pSrcCaches) { + cmd_size += vn_sizeof_array_size(srcCacheCount); + for (uint32_t i = 0; i < srcCacheCount; i++) + cmd_size += vn_sizeof_VkPipelineCache(&pSrcCaches[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkMergePipelineCaches(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipelineCache(enc, &dstCache); + vn_encode_uint32_t(enc, &srcCacheCount); + if (pSrcCaches) { + vn_encode_array_size(enc, srcCacheCount); + for (uint32_t i = 0; i < srcCacheCount; i++) + vn_encode_VkPipelineCache(enc, &pSrcCaches[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkMergePipelineCaches_reply(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip dstCache */ + /* skip srcCacheCount */ + /* skip pSrcCaches */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkMergePipelineCaches_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkMergePipelineCaches_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip dstCache */ + /* skip srcCacheCount */ + /* skip pSrcCaches */ + + return ret; +} + +static inline size_t vn_sizeof_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache); + cmd_size += vn_sizeof_uint32_t(&createInfoCount); + if (pCreateInfos) { + cmd_size += vn_sizeof_array_size(createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + cmd_size += vn_sizeof_VkGraphicsPipelineCreateInfo(&pCreateInfos[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + if (pPipelines) { + cmd_size += vn_sizeof_array_size(createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCreateGraphicsPipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipelineCache(enc, &pipelineCache); + vn_encode_uint32_t(enc, &createInfoCount); + if (pCreateInfos) { + vn_encode_array_size(enc, createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + vn_encode_VkGraphicsPipelineCreateInfo(enc, &pCreateInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (pPipelines) { + vn_encode_array_size(enc, createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + vn_encode_VkPipeline(enc, &pPipelines[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pipelineCache */ + /* skip createInfoCount */ + /* skip pCreateInfos */ + /* skip pAllocator */ + if (pPipelines) { + cmd_size += vn_sizeof_array_size(createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateGraphicsPipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pipelineCache */ + /* skip createInfoCount */ + /* skip pCreateInfos */ + /* skip pAllocator */ + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + vn_decode_VkPipeline(dec, &pPipelines[i]); + } else { + vn_decode_array_size(dec, 0); + pPipelines = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache); + cmd_size += vn_sizeof_uint32_t(&createInfoCount); + if (pCreateInfos) { + cmd_size += vn_sizeof_array_size(createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + cmd_size += vn_sizeof_VkComputePipelineCreateInfo(&pCreateInfos[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + if (pPipelines) { + cmd_size += vn_sizeof_array_size(createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCreateComputePipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipelineCache(enc, &pipelineCache); + vn_encode_uint32_t(enc, &createInfoCount); + if (pCreateInfos) { + vn_encode_array_size(enc, createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + vn_encode_VkComputePipelineCreateInfo(enc, &pCreateInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (pPipelines) { + vn_encode_array_size(enc, createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + vn_encode_VkPipeline(enc, &pPipelines[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCreateComputePipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pipelineCache */ + /* skip createInfoCount */ + /* skip pCreateInfos */ + /* skip pAllocator */ + if (pPipelines) { + cmd_size += vn_sizeof_array_size(createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateComputePipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateComputePipelines_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pipelineCache */ + /* skip createInfoCount */ + /* skip pCreateInfos */ + /* skip pAllocator */ + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, createInfoCount); + for (uint32_t i = 0; i < createInfoCount; i++) + vn_decode_VkPipeline(dec, &pPipelines[i]); + } else { + vn_decode_array_size(dec, 0); + pPipelines = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipeline(&pipeline); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipeline(enc, &pipeline); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyPipeline_reply(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pipeline */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyPipeline_EXT); + + /* skip device */ + /* skip pipeline */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkPipelineLayoutCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pPipelineLayout); + if (pPipelineLayout) + cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout); + + return cmd_size; +} + +static inline void vn_encode_vkCreatePipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkPipelineLayoutCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pPipelineLayout)) + vn_encode_VkPipelineLayout(enc, pPipelineLayout); +} + +static inline size_t vn_sizeof_vkCreatePipelineLayout_reply(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pPipelineLayout); + if (pPipelineLayout) + cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreatePipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPipelineLayout(dec, pPipelineLayout); + } else { + pPipelineLayout = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkPipelineLayout(&pipelineLayout); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyPipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkPipelineLayout(enc, &pipelineLayout); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyPipelineLayout_reply(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pipelineLayout */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyPipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT); + + /* skip device */ + /* skip pipelineLayout */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkSamplerCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pSampler); + if (pSampler) + cmd_size += vn_sizeof_VkSampler(pSampler); + + return cmd_size; +} + +static inline void vn_encode_vkCreateSampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkSamplerCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pSampler)) + vn_encode_VkSampler(enc, pSampler); +} + +static inline size_t vn_sizeof_vkCreateSampler_reply(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pSampler); + if (pSampler) + cmd_size += vn_sizeof_VkSampler(pSampler); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateSampler_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateSampler_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkSampler(dec, pSampler); + } else { + pSampler = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkSampler(&sampler); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroySampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkSampler(enc, &sampler); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroySampler_reply(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip sampler */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroySampler_reply(struct vn_cs_decoder *dec, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroySampler_EXT); + + /* skip device */ + /* skip sampler */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pSetLayout); + if (pSetLayout) + cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout); + + return cmd_size; +} + +static inline void vn_encode_vkCreateDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pSetLayout)) + vn_encode_VkDescriptorSetLayout(enc, pSetLayout); +} + +static inline size_t vn_sizeof_vkCreateDescriptorSetLayout_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pSetLayout); + if (pSetLayout) + cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDescriptorSetLayout(dec, pSetLayout); + } else { + pSetLayout = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDescriptorSetLayout(&descriptorSetLayout); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDescriptorSetLayout(enc, &descriptorSetLayout); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout_reply(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip descriptorSetLayout */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT); + + /* skip device */ + /* skip descriptorSetLayout */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkDescriptorPoolCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pDescriptorPool); + if (pDescriptorPool) + cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool); + + return cmd_size; +} + +static inline void vn_encode_vkCreateDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkDescriptorPoolCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pDescriptorPool)) + vn_encode_VkDescriptorPool(enc, pDescriptorPool); +} + +static inline size_t vn_sizeof_vkCreateDescriptorPool_reply(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pDescriptorPool); + if (pDescriptorPool) + cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDescriptorPool(dec, pDescriptorPool); + } else { + pDescriptorPool = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDescriptorPool(enc, &descriptorPool); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip descriptorPool */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT); + + /* skip device */ + /* skip descriptorPool */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkResetDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDescriptorPool(enc, &descriptorPool); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkResetDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip descriptorPool */ + /* skip flags */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkResetDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkResetDescriptorPool_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip descriptorPool */ + /* skip flags */ + + return ret; +} + +static inline size_t vn_sizeof_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pAllocateInfo); + if (pAllocateInfo) + cmd_size += vn_sizeof_VkDescriptorSetAllocateInfo(pAllocateInfo); + if (pDescriptorSets) { + cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) + cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkAllocateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pAllocateInfo)) + vn_encode_VkDescriptorSetAllocateInfo(enc, pAllocateInfo); + if (pDescriptorSets) { + vn_encode_array_size(enc, pAllocateInfo->descriptorSetCount); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) + vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkAllocateDescriptorSets_reply(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pAllocateInfo */ + if (pDescriptorSets) { + cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) + cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkAllocateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pAllocateInfo */ + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, pAllocateInfo->descriptorSetCount); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) + vn_decode_VkDescriptorSet(dec, &pDescriptorSets[i]); + } else { + vn_decode_array_size(dec, 0); + pDescriptorSets = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool); + cmd_size += vn_sizeof_uint32_t(&descriptorSetCount); + if (pDescriptorSets) { + cmd_size += vn_sizeof_array_size(descriptorSetCount); + for (uint32_t i = 0; i < descriptorSetCount; i++) + cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkFreeDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDescriptorPool(enc, &descriptorPool); + vn_encode_uint32_t(enc, &descriptorSetCount); + if (pDescriptorSets) { + vn_encode_array_size(enc, descriptorSetCount); + for (uint32_t i = 0; i < descriptorSetCount; i++) + vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkFreeDescriptorSets_reply(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip descriptorPool */ + /* skip descriptorSetCount */ + /* skip pDescriptorSets */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkFreeDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip descriptorPool */ + /* skip descriptorSetCount */ + /* skip pDescriptorSets */ + + return ret; +} + +static inline size_t vn_sizeof_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&descriptorWriteCount); + if (pDescriptorWrites) { + cmd_size += vn_sizeof_array_size(descriptorWriteCount); + for (uint32_t i = 0; i < descriptorWriteCount; i++) + cmd_size += vn_sizeof_VkWriteDescriptorSet(&pDescriptorWrites[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&descriptorCopyCount); + if (pDescriptorCopies) { + cmd_size += vn_sizeof_array_size(descriptorCopyCount); + for (uint32_t i = 0; i < descriptorCopyCount; i++) + cmd_size += vn_sizeof_VkCopyDescriptorSet(&pDescriptorCopies[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkUpdateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &descriptorWriteCount); + if (pDescriptorWrites) { + vn_encode_array_size(enc, descriptorWriteCount); + for (uint32_t i = 0; i < descriptorWriteCount; i++) + vn_encode_VkWriteDescriptorSet(enc, &pDescriptorWrites[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &descriptorCopyCount); + if (pDescriptorCopies) { + vn_encode_array_size(enc, descriptorCopyCount); + for (uint32_t i = 0; i < descriptorCopyCount; i++) + vn_encode_VkCopyDescriptorSet(enc, &pDescriptorCopies[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkUpdateDescriptorSets_reply(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip descriptorWriteCount */ + /* skip pDescriptorWrites */ + /* skip descriptorCopyCount */ + /* skip pDescriptorCopies */ + + return cmd_size; +} + +static inline void vn_decode_vkUpdateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT); + + /* skip device */ + /* skip descriptorWriteCount */ + /* skip pDescriptorWrites */ + /* skip descriptorCopyCount */ + /* skip pDescriptorCopies */ +} + +static inline size_t vn_sizeof_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkFramebufferCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pFramebuffer); + if (pFramebuffer) + cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer); + + return cmd_size; +} + +static inline void vn_encode_vkCreateFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkFramebufferCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pFramebuffer)) + vn_encode_VkFramebuffer(enc, pFramebuffer); +} + +static inline size_t vn_sizeof_vkCreateFramebuffer_reply(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pFramebuffer); + if (pFramebuffer) + cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateFramebuffer_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkFramebuffer(dec, pFramebuffer); + } else { + pFramebuffer = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkFramebuffer(&framebuffer); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkFramebuffer(enc, &framebuffer); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyFramebuffer_reply(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip framebuffer */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT); + + /* skip device */ + /* skip framebuffer */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkRenderPassCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pRenderPass); + if (pRenderPass) + cmd_size += vn_sizeof_VkRenderPass(pRenderPass); + + return cmd_size; +} + +static inline void vn_encode_vkCreateRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkRenderPassCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pRenderPass)) + vn_encode_VkRenderPass(enc, pRenderPass); +} + +static inline size_t vn_sizeof_vkCreateRenderPass_reply(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pRenderPass); + if (pRenderPass) + cmd_size += vn_sizeof_VkRenderPass(pRenderPass); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkRenderPass(dec, pRenderPass); + } else { + pRenderPass = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkRenderPass(&renderPass); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkRenderPass(enc, &renderPass); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyRenderPass_reply(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip renderPass */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyRenderPass_EXT); + + /* skip device */ + /* skip renderPass */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkRenderPass(&renderPass); + cmd_size += vn_sizeof_simple_pointer(pGranularity); + if (pGranularity) + cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity); + + return cmd_size; +} + +static inline void vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkRenderPass(enc, &renderPass); + if (vn_encode_simple_pointer(enc, pGranularity)) + vn_encode_VkExtent2D_partial(enc, pGranularity); +} + +static inline size_t vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip renderPass */ + cmd_size += vn_sizeof_simple_pointer(pGranularity); + if (pGranularity) + cmd_size += vn_sizeof_VkExtent2D(pGranularity); + + return cmd_size; +} + +static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT); + + /* skip device */ + /* skip renderPass */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkExtent2D(dec, pGranularity); + } else { + pGranularity = NULL; + } +} + +static inline size_t vn_sizeof_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkCommandPoolCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pCommandPool); + if (pCommandPool) + cmd_size += vn_sizeof_VkCommandPool(pCommandPool); + + return cmd_size; +} + +static inline void vn_encode_vkCreateCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkCommandPoolCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pCommandPool)) + vn_encode_VkCommandPool(enc, pCommandPool); +} + +static inline size_t vn_sizeof_vkCreateCommandPool_reply(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pCommandPool); + if (pCommandPool) + cmd_size += vn_sizeof_VkCommandPool(pCommandPool); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateCommandPool_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkCommandPool(dec, pCommandPool); + } else { + pCommandPool = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkCommandPool(&commandPool); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkCommandPool(enc, &commandPool); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyCommandPool_reply(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip commandPool */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyCommandPool_EXT); + + /* skip device */ + /* skip commandPool */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkCommandPool(&commandPool); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkResetCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkCommandPool(enc, &commandPool); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkResetCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip commandPool */ + /* skip flags */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkResetCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkResetCommandPool_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip commandPool */ + /* skip flags */ + + return ret; +} + +static inline size_t vn_sizeof_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pAllocateInfo); + if (pAllocateInfo) + cmd_size += vn_sizeof_VkCommandBufferAllocateInfo(pAllocateInfo); + if (pCommandBuffers) { + cmd_size += vn_sizeof_array_size(pAllocateInfo->commandBufferCount); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) + cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkAllocateCommandBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pAllocateInfo)) + vn_encode_VkCommandBufferAllocateInfo(enc, pAllocateInfo); + if (pCommandBuffers) { + vn_encode_array_size(enc, pAllocateInfo->commandBufferCount); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) + vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkAllocateCommandBuffers_reply(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pAllocateInfo */ + if (pCommandBuffers) { + cmd_size += vn_sizeof_array_size(pAllocateInfo->commandBufferCount); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) + cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkAllocateCommandBuffers_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pAllocateInfo */ + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, pAllocateInfo->commandBufferCount); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) + vn_decode_VkCommandBuffer(dec, &pCommandBuffers[i]); + } else { + vn_decode_array_size(dec, 0); + pCommandBuffers = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkCommandPool(&commandPool); + cmd_size += vn_sizeof_uint32_t(&commandBufferCount); + if (pCommandBuffers) { + cmd_size += vn_sizeof_array_size(commandBufferCount); + for (uint32_t i = 0; i < commandBufferCount; i++) + cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkFreeCommandBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkCommandPool(enc, &commandPool); + vn_encode_uint32_t(enc, &commandBufferCount); + if (pCommandBuffers) { + vn_encode_array_size(enc, commandBufferCount); + for (uint32_t i = 0; i < commandBufferCount; i++) + vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkFreeCommandBuffers_reply(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip commandPool */ + /* skip commandBufferCount */ + /* skip pCommandBuffers */ + + return cmd_size; +} + +static inline void vn_decode_vkFreeCommandBuffers_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT); + + /* skip device */ + /* skip commandPool */ + /* skip commandBufferCount */ + /* skip pCommandBuffers */ +} + +static inline size_t vn_sizeof_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pBeginInfo); + if (pBeginInfo) + cmd_size += vn_sizeof_VkCommandBufferBeginInfo(pBeginInfo); + + return cmd_size; +} + +static inline void vn_encode_vkBeginCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pBeginInfo)) + vn_encode_VkCommandBufferBeginInfo(enc, pBeginInfo); +} + +static inline size_t vn_sizeof_vkBeginCommandBuffer_reply(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip commandBuffer */ + /* skip pBeginInfo */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkBeginCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip commandBuffer */ + /* skip pBeginInfo */ + + return ret; +} + +static inline size_t vn_sizeof_vkEndCommandBuffer(VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + + return cmd_size; +} + +static inline void vn_encode_vkEndCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); +} + +static inline size_t vn_sizeof_vkEndCommandBuffer_reply(VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEndCommandBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip commandBuffer */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkEndCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEndCommandBuffer_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip commandBuffer */ + + return ret; +} + +static inline size_t vn_sizeof_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkResetCommandBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkResetCommandBuffer_reply(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip commandBuffer */ + /* skip flags */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkResetCommandBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkResetCommandBuffer_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip commandBuffer */ + /* skip flags */ + + return ret; +} + +static inline size_t vn_sizeof_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkPipelineBindPoint(&pipelineBindPoint); + cmd_size += vn_sizeof_VkPipeline(&pipeline); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBindPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkPipelineBindPoint(enc, &pipelineBindPoint); + vn_encode_VkPipeline(enc, &pipeline); +} + +static inline size_t vn_sizeof_vkCmdBindPipeline_reply(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindPipeline_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pipelineBindPoint */ + /* skip pipeline */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBindPipeline_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBindPipeline_EXT); + + /* skip commandBuffer */ + /* skip pipelineBindPoint */ + /* skip pipeline */ +} + +static inline size_t vn_sizeof_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstViewport); + cmd_size += vn_sizeof_uint32_t(&viewportCount); + if (pViewports) { + cmd_size += vn_sizeof_array_size(viewportCount); + for (uint32_t i = 0; i < viewportCount; i++) + cmd_size += vn_sizeof_VkViewport(&pViewports[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetViewport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstViewport); + vn_encode_uint32_t(enc, &viewportCount); + if (pViewports) { + vn_encode_array_size(enc, viewportCount); + for (uint32_t i = 0; i < viewportCount; i++) + vn_encode_VkViewport(enc, &pViewports[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdSetViewport_reply(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetViewport_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstViewport */ + /* skip viewportCount */ + /* skip pViewports */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetViewport_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetViewport_EXT); + + /* skip commandBuffer */ + /* skip firstViewport */ + /* skip viewportCount */ + /* skip pViewports */ +} + +static inline size_t vn_sizeof_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstScissor); + cmd_size += vn_sizeof_uint32_t(&scissorCount); + if (pScissors) { + cmd_size += vn_sizeof_array_size(scissorCount); + for (uint32_t i = 0; i < scissorCount; i++) + cmd_size += vn_sizeof_VkRect2D(&pScissors[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetScissor(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstScissor); + vn_encode_uint32_t(enc, &scissorCount); + if (pScissors) { + vn_encode_array_size(enc, scissorCount); + for (uint32_t i = 0; i < scissorCount; i++) + vn_encode_VkRect2D(enc, &pScissors[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdSetScissor_reply(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetScissor_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstScissor */ + /* skip scissorCount */ + /* skip pScissors */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetScissor_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetScissor_EXT); + + /* skip commandBuffer */ + /* skip firstScissor */ + /* skip scissorCount */ + /* skip pScissors */ +} + +static inline size_t vn_sizeof_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_float(&lineWidth); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetLineWidth(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float lineWidth) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_float(enc, &lineWidth); +} + +static inline size_t vn_sizeof_vkCmdSetLineWidth_reply(VkCommandBuffer commandBuffer, float lineWidth) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip lineWidth */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetLineWidth_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float lineWidth) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT); + + /* skip commandBuffer */ + /* skip lineWidth */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_float(&depthBiasConstantFactor); + cmd_size += vn_sizeof_float(&depthBiasClamp); + cmd_size += vn_sizeof_float(&depthBiasSlopeFactor); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthBias(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_float(enc, &depthBiasConstantFactor); + vn_encode_float(enc, &depthBiasClamp); + vn_encode_float(enc, &depthBiasSlopeFactor); +} + +static inline size_t vn_sizeof_vkCmdSetDepthBias_reply(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip depthBiasConstantFactor */ + /* skip depthBiasClamp */ + /* skip depthBiasSlopeFactor */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthBias_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT); + + /* skip commandBuffer */ + /* skip depthBiasConstantFactor */ + /* skip depthBiasClamp */ + /* skip depthBiasSlopeFactor */ +} + +static inline size_t vn_sizeof_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_array_size(4); + cmd_size += vn_sizeof_float_array(blendConstants, 4); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetBlendConstants(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_array_size(enc, 4); + vn_encode_float_array(enc, blendConstants, 4); +} + +static inline size_t vn_sizeof_vkCmdSetBlendConstants_reply(VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip blendConstants */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetBlendConstants_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT); + + /* skip commandBuffer */ + /* skip blendConstants */ +} + +static inline size_t vn_sizeof_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_float(&minDepthBounds); + cmd_size += vn_sizeof_float(&maxDepthBounds); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDepthBounds(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_float(enc, &minDepthBounds); + vn_encode_float(enc, &maxDepthBounds); +} + +static inline size_t vn_sizeof_vkCmdSetDepthBounds_reply(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip minDepthBounds */ + /* skip maxDepthBounds */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDepthBounds_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT); + + /* skip commandBuffer */ + /* skip minDepthBounds */ + /* skip maxDepthBounds */ +} + +static inline size_t vn_sizeof_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&faceMask); + cmd_size += vn_sizeof_uint32_t(&compareMask); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetStencilCompareMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &faceMask); + vn_encode_uint32_t(enc, &compareMask); +} + +static inline size_t vn_sizeof_vkCmdSetStencilCompareMask_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip compareMask */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetStencilCompareMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip compareMask */ +} + +static inline size_t vn_sizeof_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&faceMask); + cmd_size += vn_sizeof_uint32_t(&writeMask); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetStencilWriteMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &faceMask); + vn_encode_uint32_t(enc, &writeMask); +} + +static inline size_t vn_sizeof_vkCmdSetStencilWriteMask_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip writeMask */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetStencilWriteMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip writeMask */ +} + +static inline size_t vn_sizeof_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&faceMask); + cmd_size += vn_sizeof_uint32_t(&reference); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetStencilReference(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &faceMask); + vn_encode_uint32_t(enc, &reference); +} + +static inline size_t vn_sizeof_vkCmdSetStencilReference_reply(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip reference */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetStencilReference_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT); + + /* skip commandBuffer */ + /* skip faceMask */ + /* skip reference */ +} + +static inline size_t vn_sizeof_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkPipelineBindPoint(&pipelineBindPoint); + cmd_size += vn_sizeof_VkPipelineLayout(&layout); + cmd_size += vn_sizeof_uint32_t(&firstSet); + cmd_size += vn_sizeof_uint32_t(&descriptorSetCount); + if (pDescriptorSets) { + cmd_size += vn_sizeof_array_size(descriptorSetCount); + for (uint32_t i = 0; i < descriptorSetCount; i++) + cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&dynamicOffsetCount); + if (pDynamicOffsets) { + cmd_size += vn_sizeof_array_size(dynamicOffsetCount); + cmd_size += vn_sizeof_uint32_t_array(pDynamicOffsets, dynamicOffsetCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdBindDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkPipelineBindPoint(enc, &pipelineBindPoint); + vn_encode_VkPipelineLayout(enc, &layout); + vn_encode_uint32_t(enc, &firstSet); + vn_encode_uint32_t(enc, &descriptorSetCount); + if (pDescriptorSets) { + vn_encode_array_size(enc, descriptorSetCount); + for (uint32_t i = 0; i < descriptorSetCount; i++) + vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &dynamicOffsetCount); + if (pDynamicOffsets) { + vn_encode_array_size(enc, dynamicOffsetCount); + vn_encode_uint32_t_array(enc, pDynamicOffsets, dynamicOffsetCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdBindDescriptorSets_reply(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pipelineBindPoint */ + /* skip layout */ + /* skip firstSet */ + /* skip descriptorSetCount */ + /* skip pDescriptorSets */ + /* skip dynamicOffsetCount */ + /* skip pDynamicOffsets */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBindDescriptorSets_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT); + + /* skip commandBuffer */ + /* skip pipelineBindPoint */ + /* skip layout */ + /* skip firstSet */ + /* skip descriptorSetCount */ + /* skip pDescriptorSets */ + /* skip dynamicOffsetCount */ + /* skip pDynamicOffsets */ +} + +static inline size_t vn_sizeof_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceSize(&offset); + cmd_size += vn_sizeof_VkIndexType(&indexType); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBindIndexBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceSize(enc, &offset); + vn_encode_VkIndexType(enc, &indexType); +} + +static inline size_t vn_sizeof_vkCmdBindIndexBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip indexType */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBindIndexBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip indexType */ +} + +static inline size_t vn_sizeof_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstBinding); + cmd_size += vn_sizeof_uint32_t(&bindingCount); + if (pBuffers) { + cmd_size += vn_sizeof_array_size(bindingCount); + for (uint32_t i = 0; i < bindingCount; i++) + cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pOffsets) { + cmd_size += vn_sizeof_array_size(bindingCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdBindVertexBuffers(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstBinding); + vn_encode_uint32_t(enc, &bindingCount); + if (pBuffers) { + vn_encode_array_size(enc, bindingCount); + for (uint32_t i = 0; i < bindingCount; i++) + vn_encode_VkBuffer(enc, &pBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pOffsets) { + vn_encode_array_size(enc, bindingCount); + vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdBindVertexBuffers_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstBinding */ + /* skip bindingCount */ + /* skip pBuffers */ + /* skip pOffsets */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBindVertexBuffers_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT); + + /* skip commandBuffer */ + /* skip firstBinding */ + /* skip bindingCount */ + /* skip pBuffers */ + /* skip pOffsets */ +} + +static inline size_t vn_sizeof_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&vertexCount); + cmd_size += vn_sizeof_uint32_t(&instanceCount); + cmd_size += vn_sizeof_uint32_t(&firstVertex); + cmd_size += vn_sizeof_uint32_t(&firstInstance); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDraw(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &vertexCount); + vn_encode_uint32_t(enc, &instanceCount); + vn_encode_uint32_t(enc, &firstVertex); + vn_encode_uint32_t(enc, &firstInstance); +} + +static inline size_t vn_sizeof_vkCmdDraw_reply(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDraw_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip vertexCount */ + /* skip instanceCount */ + /* skip firstVertex */ + /* skip firstInstance */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDraw_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDraw_EXT); + + /* skip commandBuffer */ + /* skip vertexCount */ + /* skip instanceCount */ + /* skip firstVertex */ + /* skip firstInstance */ +} + +static inline size_t vn_sizeof_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&indexCount); + cmd_size += vn_sizeof_uint32_t(&instanceCount); + cmd_size += vn_sizeof_uint32_t(&firstIndex); + cmd_size += vn_sizeof_int32_t(&vertexOffset); + cmd_size += vn_sizeof_uint32_t(&firstInstance); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDrawIndexed(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &indexCount); + vn_encode_uint32_t(enc, &instanceCount); + vn_encode_uint32_t(enc, &firstIndex); + vn_encode_int32_t(enc, &vertexOffset); + vn_encode_uint32_t(enc, &firstInstance); +} + +static inline size_t vn_sizeof_vkCmdDrawIndexed_reply(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip indexCount */ + /* skip instanceCount */ + /* skip firstIndex */ + /* skip vertexOffset */ + /* skip firstInstance */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDrawIndexed_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT); + + /* skip commandBuffer */ + /* skip indexCount */ + /* skip instanceCount */ + /* skip firstIndex */ + /* skip vertexOffset */ + /* skip firstInstance */ +} + +static inline size_t vn_sizeof_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceSize(&offset); + cmd_size += vn_sizeof_uint32_t(&drawCount); + cmd_size += vn_sizeof_uint32_t(&stride); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDrawIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceSize(enc, &offset); + vn_encode_uint32_t(enc, &drawCount); + vn_encode_uint32_t(enc, &stride); +} + +static inline size_t vn_sizeof_vkCmdDrawIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip drawCount */ + /* skip stride */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDrawIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip drawCount */ + /* skip stride */ +} + +static inline size_t vn_sizeof_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceSize(&offset); + cmd_size += vn_sizeof_uint32_t(&drawCount); + cmd_size += vn_sizeof_uint32_t(&stride); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDrawIndexedIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceSize(enc, &offset); + vn_encode_uint32_t(enc, &drawCount); + vn_encode_uint32_t(enc, &stride); +} + +static inline size_t vn_sizeof_vkCmdDrawIndexedIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip drawCount */ + /* skip stride */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDrawIndexedIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip drawCount */ + /* skip stride */ +} + +static inline size_t vn_sizeof_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&groupCountX); + cmd_size += vn_sizeof_uint32_t(&groupCountY); + cmd_size += vn_sizeof_uint32_t(&groupCountZ); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDispatch(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &groupCountX); + vn_encode_uint32_t(enc, &groupCountY); + vn_encode_uint32_t(enc, &groupCountZ); +} + +static inline size_t vn_sizeof_vkCmdDispatch_reply(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatch_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip groupCountX */ + /* skip groupCountY */ + /* skip groupCountZ */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDispatch_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDispatch_EXT); + + /* skip commandBuffer */ + /* skip groupCountX */ + /* skip groupCountY */ + /* skip groupCountZ */ +} + +static inline size_t vn_sizeof_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceSize(&offset); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDispatchIndirect(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceSize(enc, &offset); +} + +static inline size_t vn_sizeof_vkCmdDispatchIndirect_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDispatchIndirect_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ +} + +static inline size_t vn_sizeof_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&srcBuffer); + cmd_size += vn_sizeof_VkBuffer(&dstBuffer); + cmd_size += vn_sizeof_uint32_t(®ionCount); + if (pRegions) { + cmd_size += vn_sizeof_array_size(regionCount); + for (uint32_t i = 0; i < regionCount; i++) + cmd_size += vn_sizeof_VkBufferCopy(&pRegions[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &srcBuffer); + vn_encode_VkBuffer(enc, &dstBuffer); + vn_encode_uint32_t(enc, ®ionCount); + if (pRegions) { + vn_encode_array_size(enc, regionCount); + for (uint32_t i = 0; i < regionCount; i++) + vn_encode_VkBufferCopy(enc, &pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdCopyBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcBuffer */ + /* skip dstBuffer */ + /* skip regionCount */ + /* skip pRegions */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT); + + /* skip commandBuffer */ + /* skip srcBuffer */ + /* skip dstBuffer */ + /* skip regionCount */ + /* skip pRegions */ +} + +static inline size_t vn_sizeof_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkImage(&srcImage); + cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout); + cmd_size += vn_sizeof_VkImage(&dstImage); + cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout); + cmd_size += vn_sizeof_uint32_t(®ionCount); + if (pRegions) { + cmd_size += vn_sizeof_array_size(regionCount); + for (uint32_t i = 0; i < regionCount; i++) + cmd_size += vn_sizeof_VkImageCopy(&pRegions[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkImage(enc, &srcImage); + vn_encode_VkImageLayout(enc, &srcImageLayout); + vn_encode_VkImage(enc, &dstImage); + vn_encode_VkImageLayout(enc, &dstImageLayout); + vn_encode_uint32_t(enc, ®ionCount); + if (pRegions) { + vn_encode_array_size(enc, regionCount); + for (uint32_t i = 0; i < regionCount; i++) + vn_encode_VkImageCopy(enc, &pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdCopyImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImage_EXT); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ +} + +static inline size_t vn_sizeof_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkImage(&srcImage); + cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout); + cmd_size += vn_sizeof_VkImage(&dstImage); + cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout); + cmd_size += vn_sizeof_uint32_t(®ionCount); + if (pRegions) { + cmd_size += vn_sizeof_array_size(regionCount); + for (uint32_t i = 0; i < regionCount; i++) + cmd_size += vn_sizeof_VkImageBlit(&pRegions[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkFilter(&filter); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBlitImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkImage(enc, &srcImage); + vn_encode_VkImageLayout(enc, &srcImageLayout); + vn_encode_VkImage(enc, &dstImage); + vn_encode_VkImageLayout(enc, &dstImageLayout); + vn_encode_uint32_t(enc, ®ionCount); + if (pRegions) { + vn_encode_array_size(enc, regionCount); + for (uint32_t i = 0; i < regionCount; i++) + vn_encode_VkImageBlit(enc, &pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFilter(enc, &filter); +} + +static inline size_t vn_sizeof_vkCmdBlitImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBlitImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ + /* skip filter */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBlitImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBlitImage_EXT); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ + /* skip filter */ +} + +static inline size_t vn_sizeof_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&srcBuffer); + cmd_size += vn_sizeof_VkImage(&dstImage); + cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout); + cmd_size += vn_sizeof_uint32_t(®ionCount); + if (pRegions) { + cmd_size += vn_sizeof_array_size(regionCount); + for (uint32_t i = 0; i < regionCount; i++) + cmd_size += vn_sizeof_VkBufferImageCopy(&pRegions[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyBufferToImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &srcBuffer); + vn_encode_VkImage(enc, &dstImage); + vn_encode_VkImageLayout(enc, &dstImageLayout); + vn_encode_uint32_t(enc, ®ionCount); + if (pRegions) { + vn_encode_array_size(enc, regionCount); + for (uint32_t i = 0; i < regionCount; i++) + vn_encode_VkBufferImageCopy(enc, &pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdCopyBufferToImage_reply(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcBuffer */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyBufferToImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT); + + /* skip commandBuffer */ + /* skip srcBuffer */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ +} + +static inline size_t vn_sizeof_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkImage(&srcImage); + cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout); + cmd_size += vn_sizeof_VkBuffer(&dstBuffer); + cmd_size += vn_sizeof_uint32_t(®ionCount); + if (pRegions) { + cmd_size += vn_sizeof_array_size(regionCount); + for (uint32_t i = 0; i < regionCount; i++) + cmd_size += vn_sizeof_VkBufferImageCopy(&pRegions[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyImageToBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkImage(enc, &srcImage); + vn_encode_VkImageLayout(enc, &srcImageLayout); + vn_encode_VkBuffer(enc, &dstBuffer); + vn_encode_uint32_t(enc, ®ionCount); + if (pRegions) { + vn_encode_array_size(enc, regionCount); + for (uint32_t i = 0; i < regionCount; i++) + vn_encode_VkBufferImageCopy(enc, &pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdCopyImageToBuffer_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstBuffer */ + /* skip regionCount */ + /* skip pRegions */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyImageToBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstBuffer */ + /* skip regionCount */ + /* skip pRegions */ +} + +static inline size_t vn_sizeof_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&dstBuffer); + cmd_size += vn_sizeof_VkDeviceSize(&dstOffset); + cmd_size += vn_sizeof_VkDeviceSize(&dataSize); + if (pData) { + cmd_size += vn_sizeof_array_size(dataSize); + cmd_size += vn_sizeof_blob_array(pData, dataSize); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdUpdateBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &dstBuffer); + vn_encode_VkDeviceSize(enc, &dstOffset); + vn_encode_VkDeviceSize(enc, &dataSize); + if (pData) { + vn_encode_array_size(enc, dataSize); + vn_encode_blob_array(enc, pData, dataSize); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdUpdateBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip dstBuffer */ + /* skip dstOffset */ + /* skip dataSize */ + /* skip pData */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdUpdateBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT); + + /* skip commandBuffer */ + /* skip dstBuffer */ + /* skip dstOffset */ + /* skip dataSize */ + /* skip pData */ +} + +static inline size_t vn_sizeof_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&dstBuffer); + cmd_size += vn_sizeof_VkDeviceSize(&dstOffset); + cmd_size += vn_sizeof_VkDeviceSize(&size); + cmd_size += vn_sizeof_uint32_t(&data); + + return cmd_size; +} + +static inline void vn_encode_vkCmdFillBuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &dstBuffer); + vn_encode_VkDeviceSize(enc, &dstOffset); + vn_encode_VkDeviceSize(enc, &size); + vn_encode_uint32_t(enc, &data); +} + +static inline size_t vn_sizeof_vkCmdFillBuffer_reply(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdFillBuffer_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip dstBuffer */ + /* skip dstOffset */ + /* skip size */ + /* skip data */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdFillBuffer_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdFillBuffer_EXT); + + /* skip commandBuffer */ + /* skip dstBuffer */ + /* skip dstOffset */ + /* skip size */ + /* skip data */ +} + +static inline size_t vn_sizeof_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_VkImageLayout(&imageLayout); + cmd_size += vn_sizeof_simple_pointer(pColor); + if (pColor) + cmd_size += vn_sizeof_VkClearColorValue(pColor); + cmd_size += vn_sizeof_uint32_t(&rangeCount); + if (pRanges) { + cmd_size += vn_sizeof_array_size(rangeCount); + for (uint32_t i = 0; i < rangeCount; i++) + cmd_size += vn_sizeof_VkImageSubresourceRange(&pRanges[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdClearColorImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkImage(enc, &image); + vn_encode_VkImageLayout(enc, &imageLayout); + if (vn_encode_simple_pointer(enc, pColor)) + vn_encode_VkClearColorValue(enc, pColor); + vn_encode_uint32_t(enc, &rangeCount); + if (pRanges) { + vn_encode_array_size(enc, rangeCount); + for (uint32_t i = 0; i < rangeCount; i++) + vn_encode_VkImageSubresourceRange(enc, &pRanges[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdClearColorImage_reply(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearColorImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip image */ + /* skip imageLayout */ + /* skip pColor */ + /* skip rangeCount */ + /* skip pRanges */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdClearColorImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdClearColorImage_EXT); + + /* skip commandBuffer */ + /* skip image */ + /* skip imageLayout */ + /* skip pColor */ + /* skip rangeCount */ + /* skip pRanges */ +} + +static inline size_t vn_sizeof_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_VkImageLayout(&imageLayout); + cmd_size += vn_sizeof_simple_pointer(pDepthStencil); + if (pDepthStencil) + cmd_size += vn_sizeof_VkClearDepthStencilValue(pDepthStencil); + cmd_size += vn_sizeof_uint32_t(&rangeCount); + if (pRanges) { + cmd_size += vn_sizeof_array_size(rangeCount); + for (uint32_t i = 0; i < rangeCount; i++) + cmd_size += vn_sizeof_VkImageSubresourceRange(&pRanges[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdClearDepthStencilImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkImage(enc, &image); + vn_encode_VkImageLayout(enc, &imageLayout); + if (vn_encode_simple_pointer(enc, pDepthStencil)) + vn_encode_VkClearDepthStencilValue(enc, pDepthStencil); + vn_encode_uint32_t(enc, &rangeCount); + if (pRanges) { + vn_encode_array_size(enc, rangeCount); + for (uint32_t i = 0; i < rangeCount; i++) + vn_encode_VkImageSubresourceRange(enc, &pRanges[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdClearDepthStencilImage_reply(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip image */ + /* skip imageLayout */ + /* skip pDepthStencil */ + /* skip rangeCount */ + /* skip pRanges */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdClearDepthStencilImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT); + + /* skip commandBuffer */ + /* skip image */ + /* skip imageLayout */ + /* skip pDepthStencil */ + /* skip rangeCount */ + /* skip pRanges */ +} + +static inline size_t vn_sizeof_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&attachmentCount); + if (pAttachments) { + cmd_size += vn_sizeof_array_size(attachmentCount); + for (uint32_t i = 0; i < attachmentCount; i++) + cmd_size += vn_sizeof_VkClearAttachment(&pAttachments[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&rectCount); + if (pRects) { + cmd_size += vn_sizeof_array_size(rectCount); + for (uint32_t i = 0; i < rectCount; i++) + cmd_size += vn_sizeof_VkClearRect(&pRects[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdClearAttachments(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &attachmentCount); + if (pAttachments) { + vn_encode_array_size(enc, attachmentCount); + for (uint32_t i = 0; i < attachmentCount; i++) + vn_encode_VkClearAttachment(enc, &pAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &rectCount); + if (pRects) { + vn_encode_array_size(enc, rectCount); + for (uint32_t i = 0; i < rectCount; i++) + vn_encode_VkClearRect(enc, &pRects[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdClearAttachments_reply(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdClearAttachments_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip attachmentCount */ + /* skip pAttachments */ + /* skip rectCount */ + /* skip pRects */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdClearAttachments_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdClearAttachments_EXT); + + /* skip commandBuffer */ + /* skip attachmentCount */ + /* skip pAttachments */ + /* skip rectCount */ + /* skip pRects */ +} + +static inline size_t vn_sizeof_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkImage(&srcImage); + cmd_size += vn_sizeof_VkImageLayout(&srcImageLayout); + cmd_size += vn_sizeof_VkImage(&dstImage); + cmd_size += vn_sizeof_VkImageLayout(&dstImageLayout); + cmd_size += vn_sizeof_uint32_t(®ionCount); + if (pRegions) { + cmd_size += vn_sizeof_array_size(regionCount); + for (uint32_t i = 0; i < regionCount; i++) + cmd_size += vn_sizeof_VkImageResolve(&pRegions[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdResolveImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkImage(enc, &srcImage); + vn_encode_VkImageLayout(enc, &srcImageLayout); + vn_encode_VkImage(enc, &dstImage); + vn_encode_VkImageLayout(enc, &dstImageLayout); + vn_encode_uint32_t(enc, ®ionCount); + if (pRegions) { + vn_encode_array_size(enc, regionCount); + for (uint32_t i = 0; i < regionCount; i++) + vn_encode_VkImageResolve(enc, &pRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdResolveImage_reply(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResolveImage_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdResolveImage_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdResolveImage_EXT); + + /* skip commandBuffer */ + /* skip srcImage */ + /* skip srcImageLayout */ + /* skip dstImage */ + /* skip dstImageLayout */ + /* skip regionCount */ + /* skip pRegions */ +} + +static inline size_t vn_sizeof_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkEvent(&event); + cmd_size += vn_sizeof_VkFlags(&stageMask); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkEvent(enc, &event); + vn_encode_VkFlags(enc, &stageMask); +} + +static inline size_t vn_sizeof_vkCmdSetEvent_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetEvent_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip event */ + /* skip stageMask */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetEvent_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetEvent_EXT); + + /* skip commandBuffer */ + /* skip event */ + /* skip stageMask */ +} + +static inline size_t vn_sizeof_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkEvent(&event); + cmd_size += vn_sizeof_VkFlags(&stageMask); + + return cmd_size; +} + +static inline void vn_encode_vkCmdResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkEvent(enc, &event); + vn_encode_VkFlags(enc, &stageMask); +} + +static inline size_t vn_sizeof_vkCmdResetEvent_reply(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetEvent_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip event */ + /* skip stageMask */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdResetEvent_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdResetEvent_EXT); + + /* skip commandBuffer */ + /* skip event */ + /* skip stageMask */ +} + +static inline size_t vn_sizeof_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&eventCount); + if (pEvents) { + cmd_size += vn_sizeof_array_size(eventCount); + for (uint32_t i = 0; i < eventCount; i++) + cmd_size += vn_sizeof_VkEvent(&pEvents[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkFlags(&srcStageMask); + cmd_size += vn_sizeof_VkFlags(&dstStageMask); + cmd_size += vn_sizeof_uint32_t(&memoryBarrierCount); + if (pMemoryBarriers) { + cmd_size += vn_sizeof_array_size(memoryBarrierCount); + for (uint32_t i = 0; i < memoryBarrierCount; i++) + cmd_size += vn_sizeof_VkMemoryBarrier(&pMemoryBarriers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&bufferMemoryBarrierCount); + if (pBufferMemoryBarriers) { + cmd_size += vn_sizeof_array_size(bufferMemoryBarrierCount); + for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) + cmd_size += vn_sizeof_VkBufferMemoryBarrier(&pBufferMemoryBarriers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&imageMemoryBarrierCount); + if (pImageMemoryBarriers) { + cmd_size += vn_sizeof_array_size(imageMemoryBarrierCount); + for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) + cmd_size += vn_sizeof_VkImageMemoryBarrier(&pImageMemoryBarriers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdWaitEvents(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &eventCount); + if (pEvents) { + vn_encode_array_size(enc, eventCount); + for (uint32_t i = 0; i < eventCount; i++) + vn_encode_VkEvent(enc, &pEvents[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFlags(enc, &srcStageMask); + vn_encode_VkFlags(enc, &dstStageMask); + vn_encode_uint32_t(enc, &memoryBarrierCount); + if (pMemoryBarriers) { + vn_encode_array_size(enc, memoryBarrierCount); + for (uint32_t i = 0; i < memoryBarrierCount; i++) + vn_encode_VkMemoryBarrier(enc, &pMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &bufferMemoryBarrierCount); + if (pBufferMemoryBarriers) { + vn_encode_array_size(enc, bufferMemoryBarrierCount); + for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) + vn_encode_VkBufferMemoryBarrier(enc, &pBufferMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &imageMemoryBarrierCount); + if (pImageMemoryBarriers) { + vn_encode_array_size(enc, imageMemoryBarrierCount); + for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) + vn_encode_VkImageMemoryBarrier(enc, &pImageMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdWaitEvents_reply(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWaitEvents_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip eventCount */ + /* skip pEvents */ + /* skip srcStageMask */ + /* skip dstStageMask */ + /* skip memoryBarrierCount */ + /* skip pMemoryBarriers */ + /* skip bufferMemoryBarrierCount */ + /* skip pBufferMemoryBarriers */ + /* skip imageMemoryBarrierCount */ + /* skip pImageMemoryBarriers */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdWaitEvents_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdWaitEvents_EXT); + + /* skip commandBuffer */ + /* skip eventCount */ + /* skip pEvents */ + /* skip srcStageMask */ + /* skip dstStageMask */ + /* skip memoryBarrierCount */ + /* skip pMemoryBarriers */ + /* skip bufferMemoryBarrierCount */ + /* skip pBufferMemoryBarriers */ + /* skip imageMemoryBarrierCount */ + /* skip pImageMemoryBarriers */ +} + +static inline size_t vn_sizeof_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkFlags(&srcStageMask); + cmd_size += vn_sizeof_VkFlags(&dstStageMask); + cmd_size += vn_sizeof_VkFlags(&dependencyFlags); + cmd_size += vn_sizeof_uint32_t(&memoryBarrierCount); + if (pMemoryBarriers) { + cmd_size += vn_sizeof_array_size(memoryBarrierCount); + for (uint32_t i = 0; i < memoryBarrierCount; i++) + cmd_size += vn_sizeof_VkMemoryBarrier(&pMemoryBarriers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&bufferMemoryBarrierCount); + if (pBufferMemoryBarriers) { + cmd_size += vn_sizeof_array_size(bufferMemoryBarrierCount); + for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) + cmd_size += vn_sizeof_VkBufferMemoryBarrier(&pBufferMemoryBarriers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&imageMemoryBarrierCount); + if (pImageMemoryBarriers) { + cmd_size += vn_sizeof_array_size(imageMemoryBarrierCount); + for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) + cmd_size += vn_sizeof_VkImageMemoryBarrier(&pImageMemoryBarriers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdPipelineBarrier(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkFlags(enc, &srcStageMask); + vn_encode_VkFlags(enc, &dstStageMask); + vn_encode_VkFlags(enc, &dependencyFlags); + vn_encode_uint32_t(enc, &memoryBarrierCount); + if (pMemoryBarriers) { + vn_encode_array_size(enc, memoryBarrierCount); + for (uint32_t i = 0; i < memoryBarrierCount; i++) + vn_encode_VkMemoryBarrier(enc, &pMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &bufferMemoryBarrierCount); + if (pBufferMemoryBarriers) { + vn_encode_array_size(enc, bufferMemoryBarrierCount); + for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) + vn_encode_VkBufferMemoryBarrier(enc, &pBufferMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &imageMemoryBarrierCount); + if (pImageMemoryBarriers) { + vn_encode_array_size(enc, imageMemoryBarrierCount); + for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) + vn_encode_VkImageMemoryBarrier(enc, &pImageMemoryBarriers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdPipelineBarrier_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip srcStageMask */ + /* skip dstStageMask */ + /* skip dependencyFlags */ + /* skip memoryBarrierCount */ + /* skip pMemoryBarriers */ + /* skip bufferMemoryBarrierCount */ + /* skip pBufferMemoryBarriers */ + /* skip imageMemoryBarrierCount */ + /* skip pImageMemoryBarriers */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdPipelineBarrier_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT); + + /* skip commandBuffer */ + /* skip srcStageMask */ + /* skip dstStageMask */ + /* skip dependencyFlags */ + /* skip memoryBarrierCount */ + /* skip pMemoryBarriers */ + /* skip bufferMemoryBarrierCount */ + /* skip pBufferMemoryBarriers */ + /* skip imageMemoryBarrierCount */ + /* skip pImageMemoryBarriers */ +} + +static inline size_t vn_sizeof_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&query); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBeginQuery(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &query); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkCmdBeginQuery_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQuery_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + /* skip flags */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBeginQuery_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBeginQuery_EXT); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + /* skip flags */ +} + +static inline size_t vn_sizeof_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&query); + + return cmd_size; +} + +static inline void vn_encode_vkCmdEndQuery(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &query); +} + +static inline size_t vn_sizeof_vkCmdEndQuery_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQuery_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdEndQuery_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdEndQuery_EXT); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ +} + +static inline size_t vn_sizeof_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&firstQuery); + cmd_size += vn_sizeof_uint32_t(&queryCount); + + return cmd_size; +} + +static inline void vn_encode_vkCmdResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &firstQuery); + vn_encode_uint32_t(enc, &queryCount); +} + +static inline size_t vn_sizeof_vkCmdResetQueryPool_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdResetQueryPool_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ +} + +static inline size_t vn_sizeof_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkPipelineStageFlagBits(&pipelineStage); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&query); + + return cmd_size; +} + +static inline void vn_encode_vkCmdWriteTimestamp(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkPipelineStageFlagBits(enc, &pipelineStage); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &query); +} + +static inline size_t vn_sizeof_vkCmdWriteTimestamp_reply(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pipelineStage */ + /* skip queryPool */ + /* skip query */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdWriteTimestamp_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT); + + /* skip commandBuffer */ + /* skip pipelineStage */ + /* skip queryPool */ + /* skip query */ +} + +static inline size_t vn_sizeof_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&firstQuery); + cmd_size += vn_sizeof_uint32_t(&queryCount); + cmd_size += vn_sizeof_VkBuffer(&dstBuffer); + cmd_size += vn_sizeof_VkDeviceSize(&dstOffset); + cmd_size += vn_sizeof_VkDeviceSize(&stride); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkCmdCopyQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &firstQuery); + vn_encode_uint32_t(enc, &queryCount); + vn_encode_VkBuffer(enc, &dstBuffer); + vn_encode_VkDeviceSize(enc, &dstOffset); + vn_encode_VkDeviceSize(enc, &stride); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkCmdCopyQueryPoolResults_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ + /* skip dstBuffer */ + /* skip dstOffset */ + /* skip stride */ + /* skip flags */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdCopyQueryPoolResults_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip firstQuery */ + /* skip queryCount */ + /* skip dstBuffer */ + /* skip dstOffset */ + /* skip stride */ + /* skip flags */ +} + +static inline size_t vn_sizeof_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkPipelineLayout(&layout); + cmd_size += vn_sizeof_VkFlags(&stageFlags); + cmd_size += vn_sizeof_uint32_t(&offset); + cmd_size += vn_sizeof_uint32_t(&size); + if (pValues) { + cmd_size += vn_sizeof_array_size(size); + cmd_size += vn_sizeof_blob_array(pValues, size); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdPushConstants(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkPipelineLayout(enc, &layout); + vn_encode_VkFlags(enc, &stageFlags); + vn_encode_uint32_t(enc, &offset); + vn_encode_uint32_t(enc, &size); + if (pValues) { + vn_encode_array_size(enc, size); + vn_encode_blob_array(enc, pValues, size); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdPushConstants_reply(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdPushConstants_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip layout */ + /* skip stageFlags */ + /* skip offset */ + /* skip size */ + /* skip pValues */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdPushConstants_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdPushConstants_EXT); + + /* skip commandBuffer */ + /* skip layout */ + /* skip stageFlags */ + /* skip offset */ + /* skip size */ + /* skip pValues */ +} + +static inline size_t vn_sizeof_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pRenderPassBegin); + if (pRenderPassBegin) + cmd_size += vn_sizeof_VkRenderPassBeginInfo(pRenderPassBegin); + cmd_size += vn_sizeof_VkSubpassContents(&contents); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBeginRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pRenderPassBegin)) + vn_encode_VkRenderPassBeginInfo(enc, pRenderPassBegin); + vn_encode_VkSubpassContents(enc, &contents); +} + +static inline size_t vn_sizeof_vkCmdBeginRenderPass_reply(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pRenderPassBegin */ + /* skip contents */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBeginRenderPass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT); + + /* skip commandBuffer */ + /* skip pRenderPassBegin */ + /* skip contents */ +} + +static inline size_t vn_sizeof_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkSubpassContents(&contents); + + return cmd_size; +} + +static inline void vn_encode_vkCmdNextSubpass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkSubpassContents(enc, &contents); +} + +static inline size_t vn_sizeof_vkCmdNextSubpass_reply(VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip contents */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdNextSubpass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdNextSubpass_EXT); + + /* skip commandBuffer */ + /* skip contents */ +} + +static inline size_t vn_sizeof_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + + return cmd_size; +} + +static inline void vn_encode_vkCmdEndRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); +} + +static inline size_t vn_sizeof_vkCmdEndRenderPass_reply(VkCommandBuffer commandBuffer) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdEndRenderPass_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT); + + /* skip commandBuffer */ +} + +static inline size_t vn_sizeof_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&commandBufferCount); + if (pCommandBuffers) { + cmd_size += vn_sizeof_array_size(commandBufferCount); + for (uint32_t i = 0; i < commandBufferCount; i++) + cmd_size += vn_sizeof_VkCommandBuffer(&pCommandBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdExecuteCommands(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &commandBufferCount); + if (pCommandBuffers) { + vn_encode_array_size(enc, commandBufferCount); + for (uint32_t i = 0; i < commandBufferCount; i++) + vn_encode_VkCommandBuffer(enc, &pCommandBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdExecuteCommands_reply(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip commandBufferCount */ + /* skip pCommandBuffers */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdExecuteCommands_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT); + + /* skip commandBuffer */ + /* skip commandBufferCount */ + /* skip pCommandBuffers */ +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pFeatures); + if (pFeatures) + cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pFeatures)) + vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pFeatures); + if (pFeatures) + cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures); + } else { + pFeatures = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pProperties); + if (pProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pProperties)) + vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pProperties); + if (pProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPhysicalDeviceProperties2(dec, pProperties); + } else { + pProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_VkFormat(&format); + cmd_size += vn_sizeof_simple_pointer(pFormatProperties); + if (pFormatProperties) + cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + vn_encode_VkFormat(enc, &format); + if (vn_encode_simple_pointer(enc, pFormatProperties)) + vn_encode_VkFormatProperties2_partial(enc, pFormatProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip format */ + cmd_size += vn_sizeof_simple_pointer(pFormatProperties); + if (pFormatProperties) + cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT); + + /* skip physicalDevice */ + /* skip format */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkFormatProperties2(dec, pFormatProperties); + } else { + pFormatProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo); + if (pImageFormatInfo) + cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo); + cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties); + if (pImageFormatProperties) + cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pImageFormatInfo)) + vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo); + if (vn_encode_simple_pointer(enc, pImageFormatProperties)) + vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip physicalDevice */ + /* skip pImageFormatInfo */ + cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties); + if (pImageFormatProperties) + cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties); + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip physicalDevice */ + /* skip pImageFormatInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties); + } else { + pImageFormatProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount); + if (pQueueFamilyPropertyCount) + cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount); + if (pQueueFamilyProperties) { + cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount)) + vn_encode_uint32_t(enc, pQueueFamilyPropertyCount); + if (pQueueFamilyProperties) { + vn_encode_array_size(enc, *pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount); + if (pQueueFamilyPropertyCount) + cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount); + if (pQueueFamilyProperties) { + cmd_size += vn_sizeof_array_size(*pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pQueueFamilyPropertyCount); + } else { + pQueueFamilyPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pQueueFamilyPropertyCount); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) + vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pQueueFamilyProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pMemoryProperties); + if (pMemoryProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pMemoryProperties)) + vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + cmd_size += vn_sizeof_simple_pointer(pMemoryProperties); + if (pMemoryProperties) + cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT); + + /* skip physicalDevice */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties); + } else { + pMemoryProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pFormatInfo); + if (pFormatInfo) + cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo); + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pFormatInfo)) + vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo); + if (vn_encode_simple_pointer(enc, pPropertyCount)) + vn_encode_uint32_t(enc, pPropertyCount); + if (pProperties) { + vn_encode_array_size(enc, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip pFormatInfo */ + cmd_size += vn_sizeof_simple_pointer(pPropertyCount); + if (pPropertyCount) + cmd_size += vn_sizeof_uint32_t(pPropertyCount); + if (pProperties) { + cmd_size += vn_sizeof_array_size(*pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT); + + /* skip physicalDevice */ + /* skip pFormatInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPropertyCount); + } else { + pPropertyCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPropertyCount); + for (uint32_t i = 0; i < *pPropertyCount; i++) + vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkCommandPool(&commandPool); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkTrimCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkCommandPool(enc, &commandPool); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkTrimCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip commandPool */ + /* skip flags */ + + return cmd_size; +} + +static inline void vn_decode_vkTrimCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkTrimCommandPool_EXT); + + /* skip device */ + /* skip commandPool */ + /* skip flags */ +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo); + if (pExternalBufferInfo) + cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo); + cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties); + if (pExternalBufferProperties) + cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pExternalBufferInfo)) + vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo); + if (vn_encode_simple_pointer(enc, pExternalBufferProperties)) + vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip pExternalBufferInfo */ + cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties); + if (pExternalBufferProperties) + cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT); + + /* skip physicalDevice */ + /* skip pExternalBufferInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties); + } else { + pExternalBufferProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo); + if (pExternalSemaphoreInfo) + cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo); + cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties); + if (pExternalSemaphoreProperties) + cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo)) + vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo); + if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties)) + vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip pExternalSemaphoreInfo */ + cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties); + if (pExternalSemaphoreProperties) + cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT); + + /* skip physicalDevice */ + /* skip pExternalSemaphoreInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties); + } else { + pExternalSemaphoreProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice); + cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo); + if (pExternalFenceInfo) + cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo); + cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties); + if (pExternalFenceProperties) + cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkPhysicalDevice(enc, &physicalDevice); + if (vn_encode_simple_pointer(enc, pExternalFenceInfo)) + vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo); + if (vn_encode_simple_pointer(enc, pExternalFenceProperties)) + vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties); +} + +static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip physicalDevice */ + /* skip pExternalFenceInfo */ + cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties); + if (pExternalFenceProperties) + cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties); + + return cmd_size; +} + +static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT); + + /* skip physicalDevice */ + /* skip pExternalFenceInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties); + } else { + pExternalFenceProperties = NULL; + } +} + +static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkInstance(&instance); + cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount); + if (pPhysicalDeviceGroupCount) + cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount); + if (pPhysicalDeviceGroupProperties) { + cmd_size += vn_sizeof_array_size(*pPhysicalDeviceGroupCount); + for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) + cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkInstance(enc, &instance); + if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount)) + vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount); + if (pPhysicalDeviceGroupProperties) { + vn_encode_array_size(enc, *pPhysicalDeviceGroupCount); + for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) + vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip instance */ + cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount); + if (pPhysicalDeviceGroupCount) + cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount); + if (pPhysicalDeviceGroupProperties) { + cmd_size += vn_sizeof_array_size(*pPhysicalDeviceGroupCount); + for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) + cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip instance */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount); + } else { + pPhysicalDeviceGroupCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pPhysicalDeviceGroupCount); + for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) + vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]); + } else { + vn_decode_array_size(dec, 0); + pPhysicalDeviceGroupProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&heapIndex); + cmd_size += vn_sizeof_uint32_t(&localDeviceIndex); + cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex); + cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */ + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &heapIndex); + vn_encode_uint32_t(enc, &localDeviceIndex); + vn_encode_uint32_t(enc, &remoteDeviceIndex); + vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */ +} + +static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip heapIndex */ + /* skip localDeviceIndex */ + /* skip remoteDeviceIndex */ + cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); + if (pPeerMemoryFeatures) + cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures); + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT); + + /* skip device */ + /* skip heapIndex */ + /* skip localDeviceIndex */ + /* skip remoteDeviceIndex */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkFlags(dec, pPeerMemoryFeatures); + } else { + pPeerMemoryFeatures = NULL; + } +} + +static inline size_t vn_sizeof_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&bindInfoCount); + if (pBindInfos) { + cmd_size += vn_sizeof_array_size(bindInfoCount); + for (uint32_t i = 0; i < bindInfoCount; i++) + cmd_size += vn_sizeof_VkBindBufferMemoryInfo(&pBindInfos[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkBindBufferMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &bindInfoCount); + if (pBindInfos) { + vn_encode_array_size(enc, bindInfoCount); + for (uint32_t i = 0; i < bindInfoCount; i++) + vn_encode_VkBindBufferMemoryInfo(enc, &pBindInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkBindBufferMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindBufferMemory2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip bindInfoCount */ + /* skip pBindInfos */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkBindBufferMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkBindBufferMemory2_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip bindInfoCount */ + /* skip pBindInfos */ + + return ret; +} + +static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_uint32_t(&bindInfoCount); + if (pBindInfos) { + cmd_size += vn_sizeof_array_size(bindInfoCount); + for (uint32_t i = 0; i < bindInfoCount; i++) + cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_uint32_t(enc, &bindInfoCount); + if (pBindInfos) { + vn_encode_array_size(enc, bindInfoCount); + for (uint32_t i = 0; i < bindInfoCount; i++) + vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip bindInfoCount */ + /* skip pBindInfos */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip bindInfoCount */ + /* skip pBindInfos */ + + return ret; +} + +static inline size_t vn_sizeof_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&deviceMask); + + return cmd_size; +} + +static inline void vn_encode_vkCmdSetDeviceMask(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &deviceMask); +} + +static inline size_t vn_sizeof_vkCmdSetDeviceMask_reply(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip deviceMask */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdSetDeviceMask_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT); + + /* skip commandBuffer */ + /* skip deviceMask */ +} + +static inline size_t vn_sizeof_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&baseGroupX); + cmd_size += vn_sizeof_uint32_t(&baseGroupY); + cmd_size += vn_sizeof_uint32_t(&baseGroupZ); + cmd_size += vn_sizeof_uint32_t(&groupCountX); + cmd_size += vn_sizeof_uint32_t(&groupCountY); + cmd_size += vn_sizeof_uint32_t(&groupCountZ); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDispatchBase(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &baseGroupX); + vn_encode_uint32_t(enc, &baseGroupY); + vn_encode_uint32_t(enc, &baseGroupZ); + vn_encode_uint32_t(enc, &groupCountX); + vn_encode_uint32_t(enc, &groupCountY); + vn_encode_uint32_t(enc, &groupCountZ); +} + +static inline size_t vn_sizeof_vkCmdDispatchBase_reply(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDispatchBase_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip baseGroupX */ + /* skip baseGroupY */ + /* skip baseGroupZ */ + /* skip groupCountX */ + /* skip groupCountY */ + /* skip groupCountZ */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDispatchBase_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDispatchBase_EXT); + + /* skip commandBuffer */ + /* skip baseGroupX */ + /* skip baseGroupY */ + /* skip baseGroupZ */ + /* skip groupCountX */ + /* skip groupCountY */ + /* skip groupCountZ */ +} + +static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate); + if (pDescriptorUpdateTemplate) + cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate); + + return cmd_size; +} + +static inline void vn_encode_vkCreateDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkDescriptorUpdateTemplateCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pDescriptorUpdateTemplate)) + vn_encode_VkDescriptorUpdateTemplate(enc, pDescriptorUpdateTemplate); +} + +static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate); + if (pDescriptorUpdateTemplate) + cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDescriptorUpdateTemplate(dec, pDescriptorUpdateTemplate); + } else { + pDescriptorUpdateTemplate = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(&descriptorUpdateTemplate); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkDescriptorUpdateTemplate(enc, &descriptorUpdateTemplate); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip descriptorUpdateTemplate */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT); + + /* skip device */ + /* skip descriptorUpdateTemplate */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkBufferMemoryRequirementsInfo2(pInfo); + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_encode_vkGetBufferMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkBufferMemoryRequirementsInfo2(enc, pInfo); + if (vn_encode_simple_pointer(enc, pMemoryRequirements)) + vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements); +} + +static inline size_t vn_sizeof_vkGetBufferMemoryRequirements2_reply(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pInfo */ + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_decode_vkGetBufferMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT); + + /* skip device */ + /* skip pInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements); + } else { + pMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo); + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo); + if (vn_encode_simple_pointer(enc, pMemoryRequirements)) + vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements); +} + +static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pInfo */ + cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements); + if (pMemoryRequirements) + cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements); + + return cmd_size; +} + +static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT); + + /* skip device */ + /* skip pInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements); + } else { + pMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo); + cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirementCount) + cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo); + if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount)) + vn_encode_uint32_t(enc, pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + vn_encode_array_size(enc, *pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pInfo */ + cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirementCount) + cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount); + if (pSparseMemoryRequirements) { + cmd_size += vn_sizeof_array_size(*pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT); + + /* skip device */ + /* skip pInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint32_t(dec, pSparseMemoryRequirementCount); + } else { + pSparseMemoryRequirementCount = NULL; + } + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, *pSparseMemoryRequirementCount); + for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) + vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]); + } else { + vn_decode_array_size(dec, 0); + pSparseMemoryRequirements = NULL; + } +} + +static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion); + if (pYcbcrConversion) + cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion); + + return cmd_size; +} + +static inline void vn_encode_vkCreateSamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkSamplerYcbcrConversionCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pYcbcrConversion)) + vn_encode_VkSamplerYcbcrConversion(enc, pYcbcrConversion); +} + +static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion_reply(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion); + if (pYcbcrConversion) + cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateSamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkSamplerYcbcrConversion(dec, pYcbcrConversion); + } else { + pYcbcrConversion = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkSamplerYcbcrConversion(&ycbcrConversion); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + + return cmd_size; +} + +static inline void vn_encode_vkDestroySamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkSamplerYcbcrConversion(enc, &ycbcrConversion); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); +} + +static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion_reply(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip ycbcrConversion */ + /* skip pAllocator */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroySamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT); + + /* skip device */ + /* skip ycbcrConversion */ + /* skip pAllocator */ +} + +static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pQueueInfo); + if (pQueueInfo) + cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo); + cmd_size += vn_sizeof_simple_pointer(pQueue); + if (pQueue) + cmd_size += vn_sizeof_VkQueue(pQueue); + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pQueueInfo)) + vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo); + if (vn_encode_simple_pointer(enc, pQueue)) + vn_encode_VkQueue(enc, pQueue); +} + +static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pQueueInfo */ + cmd_size += vn_sizeof_simple_pointer(pQueue); + if (pQueue) + cmd_size += vn_sizeof_VkQueue(pQueue); + + return cmd_size; +} + +static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT); + + /* skip device */ + /* skip pQueueInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkQueue(dec, pQueue); + } else { + pQueue = NULL; + } +} + +static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pSupport); + if (pSupport) + cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport_partial(pSupport); + + return cmd_size; +} + +static inline void vn_encode_vkGetDescriptorSetLayoutSupport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pSupport)) + vn_encode_VkDescriptorSetLayoutSupport_partial(enc, pSupport); +} + +static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip device */ + /* skip pCreateInfo */ + cmd_size += vn_sizeof_simple_pointer(pSupport); + if (pSupport) + cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport(pSupport); + + return cmd_size; +} + +static inline void vn_decode_vkGetDescriptorSetLayoutSupport_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT); + + /* skip device */ + /* skip pCreateInfo */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkDescriptorSetLayoutSupport(dec, pSupport); + } else { + pSupport = NULL; + } +} + +static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkRenderPassCreateInfo2(pCreateInfo); + cmd_size += vn_sizeof_simple_pointer(pAllocator); + if (pAllocator) + assert(false); + cmd_size += vn_sizeof_simple_pointer(pRenderPass); + if (pRenderPass) + cmd_size += vn_sizeof_VkRenderPass(pRenderPass); + + return cmd_size; +} + +static inline void vn_encode_vkCreateRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkRenderPassCreateInfo2(enc, pCreateInfo); + if (vn_encode_simple_pointer(enc, pAllocator)) + assert(false); + if (vn_encode_simple_pointer(enc, pRenderPass)) + vn_encode_VkRenderPass(enc, pRenderPass); +} + +static inline size_t vn_sizeof_vkCreateRenderPass2_reply(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + cmd_size += vn_sizeof_simple_pointer(pRenderPass); + if (pRenderPass) + cmd_size += vn_sizeof_VkRenderPass(pRenderPass); + + return cmd_size; +} + +static inline VkResult vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass2_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pCreateInfo */ + /* skip pAllocator */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkRenderPass(dec, pRenderPass); + } else { + pRenderPass = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pRenderPassBegin); + if (pRenderPassBegin) + cmd_size += vn_sizeof_VkRenderPassBeginInfo(pRenderPassBegin); + cmd_size += vn_sizeof_simple_pointer(pSubpassBeginInfo); + if (pSubpassBeginInfo) + cmd_size += vn_sizeof_VkSubpassBeginInfo(pSubpassBeginInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBeginRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pRenderPassBegin)) + vn_encode_VkRenderPassBeginInfo(enc, pRenderPassBegin); + if (vn_encode_simple_pointer(enc, pSubpassBeginInfo)) + vn_encode_VkSubpassBeginInfo(enc, pSubpassBeginInfo); +} + +static inline size_t vn_sizeof_vkCmdBeginRenderPass2_reply(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pRenderPassBegin */ + /* skip pSubpassBeginInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBeginRenderPass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT); + + /* skip commandBuffer */ + /* skip pRenderPassBegin */ + /* skip pSubpassBeginInfo */ +} + +static inline size_t vn_sizeof_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pSubpassBeginInfo); + if (pSubpassBeginInfo) + cmd_size += vn_sizeof_VkSubpassBeginInfo(pSubpassBeginInfo); + cmd_size += vn_sizeof_simple_pointer(pSubpassEndInfo); + if (pSubpassEndInfo) + cmd_size += vn_sizeof_VkSubpassEndInfo(pSubpassEndInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdNextSubpass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pSubpassBeginInfo)) + vn_encode_VkSubpassBeginInfo(enc, pSubpassBeginInfo); + if (vn_encode_simple_pointer(enc, pSubpassEndInfo)) + vn_encode_VkSubpassEndInfo(enc, pSubpassEndInfo); +} + +static inline size_t vn_sizeof_vkCmdNextSubpass2_reply(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pSubpassBeginInfo */ + /* skip pSubpassEndInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdNextSubpass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT); + + /* skip commandBuffer */ + /* skip pSubpassBeginInfo */ + /* skip pSubpassEndInfo */ +} + +static inline size_t vn_sizeof_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_simple_pointer(pSubpassEndInfo); + if (pSubpassEndInfo) + cmd_size += vn_sizeof_VkSubpassEndInfo(pSubpassEndInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCmdEndRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + if (vn_encode_simple_pointer(enc, pSubpassEndInfo)) + vn_encode_VkSubpassEndInfo(enc, pSubpassEndInfo); +} + +static inline size_t vn_sizeof_vkCmdEndRenderPass2_reply(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip pSubpassEndInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdEndRenderPass2_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT); + + /* skip commandBuffer */ + /* skip pSubpassEndInfo */ +} + +static inline size_t vn_sizeof_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkSemaphore(&semaphore); + cmd_size += vn_sizeof_simple_pointer(pValue); /* out */ + + return cmd_size; +} + +static inline void vn_encode_vkGetSemaphoreCounterValue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkSemaphore(enc, &semaphore); + vn_encode_simple_pointer(enc, pValue); /* out */ +} + +static inline size_t vn_sizeof_vkGetSemaphoreCounterValue_reply(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip semaphore */ + cmd_size += vn_sizeof_simple_pointer(pValue); + if (pValue) + cmd_size += vn_sizeof_uint64_t(pValue); + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetSemaphoreCounterValue_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip semaphore */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_uint64_t(dec, pValue); + } else { + pValue = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pWaitInfo); + if (pWaitInfo) + cmd_size += vn_sizeof_VkSemaphoreWaitInfo(pWaitInfo); + cmd_size += vn_sizeof_uint64_t(&timeout); + + return cmd_size; +} + +static inline void vn_encode_vkWaitSemaphores(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pWaitInfo)) + vn_encode_VkSemaphoreWaitInfo(enc, pWaitInfo); + vn_encode_uint64_t(enc, &timeout); +} + +static inline size_t vn_sizeof_vkWaitSemaphores_reply(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pWaitInfo */ + /* skip timeout */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkWaitSemaphores_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphores_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pWaitInfo */ + /* skip timeout */ + + return ret; +} + +static inline size_t vn_sizeof_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pSignalInfo); + if (pSignalInfo) + cmd_size += vn_sizeof_VkSemaphoreSignalInfo(pSignalInfo); + + return cmd_size; +} + +static inline void vn_encode_vkSignalSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pSignalInfo)) + vn_encode_VkSemaphoreSignalInfo(enc, pSignalInfo); +} + +static inline size_t vn_sizeof_vkSignalSemaphore_reply(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip pSignalInfo */ + + return cmd_size; +} + +static inline VkResult vn_decode_vkSignalSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkSignalSemaphore_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip pSignalInfo */ + + return ret; +} + +static inline size_t vn_sizeof_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceSize(&offset); + cmd_size += vn_sizeof_VkBuffer(&countBuffer); + cmd_size += vn_sizeof_VkDeviceSize(&countBufferOffset); + cmd_size += vn_sizeof_uint32_t(&maxDrawCount); + cmd_size += vn_sizeof_uint32_t(&stride); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDrawIndirectCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceSize(enc, &offset); + vn_encode_VkBuffer(enc, &countBuffer); + vn_encode_VkDeviceSize(enc, &countBufferOffset); + vn_encode_uint32_t(enc, &maxDrawCount); + vn_encode_uint32_t(enc, &stride); +} + +static inline size_t vn_sizeof_vkCmdDrawIndirectCount_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip countBuffer */ + /* skip countBufferOffset */ + /* skip maxDrawCount */ + /* skip stride */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDrawIndirectCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip countBuffer */ + /* skip countBufferOffset */ + /* skip maxDrawCount */ + /* skip stride */ +} + +static inline size_t vn_sizeof_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkBuffer(&buffer); + cmd_size += vn_sizeof_VkDeviceSize(&offset); + cmd_size += vn_sizeof_VkBuffer(&countBuffer); + cmd_size += vn_sizeof_VkDeviceSize(&countBufferOffset); + cmd_size += vn_sizeof_uint32_t(&maxDrawCount); + cmd_size += vn_sizeof_uint32_t(&stride); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDrawIndexedIndirectCount(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkBuffer(enc, &buffer); + vn_encode_VkDeviceSize(enc, &offset); + vn_encode_VkBuffer(enc, &countBuffer); + vn_encode_VkDeviceSize(enc, &countBufferOffset); + vn_encode_uint32_t(enc, &maxDrawCount); + vn_encode_uint32_t(enc, &stride); +} + +static inline size_t vn_sizeof_vkCmdDrawIndexedIndirectCount_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip countBuffer */ + /* skip countBufferOffset */ + /* skip maxDrawCount */ + /* skip stride */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDrawIndexedIndirectCount_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT); + + /* skip commandBuffer */ + /* skip buffer */ + /* skip offset */ + /* skip countBuffer */ + /* skip countBufferOffset */ + /* skip maxDrawCount */ + /* skip stride */ +} + +static inline size_t vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstBinding); + cmd_size += vn_sizeof_uint32_t(&bindingCount); + if (pBuffers) { + cmd_size += vn_sizeof_array_size(bindingCount); + for (uint32_t i = 0; i < bindingCount; i++) + cmd_size += vn_sizeof_VkBuffer(&pBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pOffsets) { + cmd_size += vn_sizeof_array_size(bindingCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pOffsets, bindingCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pSizes) { + cmd_size += vn_sizeof_array_size(bindingCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pSizes, bindingCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdBindTransformFeedbackBuffersEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstBinding); + vn_encode_uint32_t(enc, &bindingCount); + if (pBuffers) { + vn_encode_array_size(enc, bindingCount); + for (uint32_t i = 0; i < bindingCount; i++) + vn_encode_VkBuffer(enc, &pBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pOffsets) { + vn_encode_array_size(enc, bindingCount); + vn_encode_VkDeviceSize_array(enc, pOffsets, bindingCount); + } else { + vn_encode_array_size(enc, 0); + } + if (pSizes) { + vn_encode_array_size(enc, bindingCount); + vn_encode_VkDeviceSize_array(enc, pSizes, bindingCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdBindTransformFeedbackBuffersEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstBinding */ + /* skip bindingCount */ + /* skip pBuffers */ + /* skip pOffsets */ + /* skip pSizes */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBindTransformFeedbackBuffersEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT); + + /* skip commandBuffer */ + /* skip firstBinding */ + /* skip bindingCount */ + /* skip pBuffers */ + /* skip pOffsets */ + /* skip pSizes */ +} + +static inline size_t vn_sizeof_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstCounterBuffer); + cmd_size += vn_sizeof_uint32_t(&counterBufferCount); + if (pCounterBuffers) { + cmd_size += vn_sizeof_array_size(counterBufferCount); + for (uint32_t i = 0; i < counterBufferCount; i++) + cmd_size += vn_sizeof_VkBuffer(&pCounterBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pCounterBufferOffsets) { + cmd_size += vn_sizeof_array_size(counterBufferCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pCounterBufferOffsets, counterBufferCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdBeginTransformFeedbackEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstCounterBuffer); + vn_encode_uint32_t(enc, &counterBufferCount); + if (pCounterBuffers) { + vn_encode_array_size(enc, counterBufferCount); + for (uint32_t i = 0; i < counterBufferCount; i++) + vn_encode_VkBuffer(enc, &pCounterBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pCounterBufferOffsets) { + vn_encode_array_size(enc, counterBufferCount); + vn_encode_VkDeviceSize_array(enc, pCounterBufferOffsets, counterBufferCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdBeginTransformFeedbackEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstCounterBuffer */ + /* skip counterBufferCount */ + /* skip pCounterBuffers */ + /* skip pCounterBufferOffsets */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBeginTransformFeedbackEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT); + + /* skip commandBuffer */ + /* skip firstCounterBuffer */ + /* skip counterBufferCount */ + /* skip pCounterBuffers */ + /* skip pCounterBufferOffsets */ +} + +static inline size_t vn_sizeof_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&firstCounterBuffer); + cmd_size += vn_sizeof_uint32_t(&counterBufferCount); + if (pCounterBuffers) { + cmd_size += vn_sizeof_array_size(counterBufferCount); + for (uint32_t i = 0; i < counterBufferCount; i++) + cmd_size += vn_sizeof_VkBuffer(&pCounterBuffers[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pCounterBufferOffsets) { + cmd_size += vn_sizeof_array_size(counterBufferCount); + cmd_size += vn_sizeof_VkDeviceSize_array(pCounterBufferOffsets, counterBufferCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + + return cmd_size; +} + +static inline void vn_encode_vkCmdEndTransformFeedbackEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &firstCounterBuffer); + vn_encode_uint32_t(enc, &counterBufferCount); + if (pCounterBuffers) { + vn_encode_array_size(enc, counterBufferCount); + for (uint32_t i = 0; i < counterBufferCount; i++) + vn_encode_VkBuffer(enc, &pCounterBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pCounterBufferOffsets) { + vn_encode_array_size(enc, counterBufferCount); + vn_encode_VkDeviceSize_array(enc, pCounterBufferOffsets, counterBufferCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline size_t vn_sizeof_vkCmdEndTransformFeedbackEXT_reply(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip firstCounterBuffer */ + /* skip counterBufferCount */ + /* skip pCounterBuffers */ + /* skip pCounterBufferOffsets */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdEndTransformFeedbackEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT); + + /* skip commandBuffer */ + /* skip firstCounterBuffer */ + /* skip counterBufferCount */ + /* skip pCounterBuffers */ + /* skip pCounterBufferOffsets */ +} + +static inline size_t vn_sizeof_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&query); + cmd_size += vn_sizeof_VkFlags(&flags); + cmd_size += vn_sizeof_uint32_t(&index); + + return cmd_size; +} + +static inline void vn_encode_vkCmdBeginQueryIndexedEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &query); + vn_encode_VkFlags(enc, &flags); + vn_encode_uint32_t(enc, &index); +} + +static inline size_t vn_sizeof_vkCmdBeginQueryIndexedEXT_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + /* skip flags */ + /* skip index */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdBeginQueryIndexedEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + /* skip flags */ + /* skip index */ +} + +static inline size_t vn_sizeof_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_VkQueryPool(&queryPool); + cmd_size += vn_sizeof_uint32_t(&query); + cmd_size += vn_sizeof_uint32_t(&index); + + return cmd_size; +} + +static inline void vn_encode_vkCmdEndQueryIndexedEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_VkQueryPool(enc, &queryPool); + vn_encode_uint32_t(enc, &query); + vn_encode_uint32_t(enc, &index); +} + +static inline size_t vn_sizeof_vkCmdEndQueryIndexedEXT_reply(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + /* skip index */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdEndQueryIndexedEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT); + + /* skip commandBuffer */ + /* skip queryPool */ + /* skip query */ + /* skip index */ +} + +static inline size_t vn_sizeof_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer); + cmd_size += vn_sizeof_uint32_t(&instanceCount); + cmd_size += vn_sizeof_uint32_t(&firstInstance); + cmd_size += vn_sizeof_VkBuffer(&counterBuffer); + cmd_size += vn_sizeof_VkDeviceSize(&counterBufferOffset); + cmd_size += vn_sizeof_uint32_t(&counterOffset); + cmd_size += vn_sizeof_uint32_t(&vertexStride); + + return cmd_size; +} + +static inline void vn_encode_vkCmdDrawIndirectByteCountEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkCommandBuffer(enc, &commandBuffer); + vn_encode_uint32_t(enc, &instanceCount); + vn_encode_uint32_t(enc, &firstInstance); + vn_encode_VkBuffer(enc, &counterBuffer); + vn_encode_VkDeviceSize(enc, &counterBufferOffset); + vn_encode_uint32_t(enc, &counterOffset); + vn_encode_uint32_t(enc, &vertexStride); +} + +static inline size_t vn_sizeof_vkCmdDrawIndirectByteCountEXT_reply(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip commandBuffer */ + /* skip instanceCount */ + /* skip firstInstance */ + /* skip counterBuffer */ + /* skip counterBufferOffset */ + /* skip counterOffset */ + /* skip vertexStride */ + + return cmd_size; +} + +static inline void vn_decode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT); + + /* skip commandBuffer */ + /* skip instanceCount */ + /* skip firstInstance */ + /* skip counterBuffer */ + /* skip counterBufferOffset */ + /* skip counterOffset */ + /* skip vertexStride */ +} + +static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_VkImage(&image); + cmd_size += vn_sizeof_simple_pointer(pProperties); + if (pProperties) + cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties); + + return cmd_size; +} + +static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + vn_encode_VkImage(enc, &image); + if (vn_encode_simple_pointer(enc, pProperties)) + vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties); +} + +static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkResult ret; + cmd_size += vn_sizeof_VkResult(&ret); + /* skip device */ + /* skip image */ + cmd_size += vn_sizeof_simple_pointer(pProperties); + if (pProperties) + cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties); + + return cmd_size; +} + +static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT); + + VkResult ret; + vn_decode_VkResult(dec, &ret); + /* skip device */ + /* skip image */ + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties); + } else { + pProperties = NULL; + } + + return ret; +} + +static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkBufferDeviceAddressInfo(pInfo); + + return cmd_size; +} + +static inline void vn_encode_vkGetBufferOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkBufferDeviceAddressInfo(enc, pInfo); +} + +static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + uint64_t ret; + cmd_size += vn_sizeof_uint64_t(&ret); + /* skip device */ + /* skip pInfo */ + + return cmd_size; +} + +static inline uint64_t vn_decode_vkGetBufferOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT); + + uint64_t ret; + vn_decode_uint64_t(dec, &ret); + /* skip device */ + /* skip pInfo */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkBufferDeviceAddressInfo(pInfo); + + return cmd_size; +} + +static inline void vn_encode_vkGetBufferDeviceAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkBufferDeviceAddressInfo(enc, pInfo); +} + +static inline size_t vn_sizeof_vkGetBufferDeviceAddress_reply(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + VkDeviceAddress ret; + cmd_size += vn_sizeof_VkDeviceAddress(&ret); + /* skip device */ + /* skip pInfo */ + + return cmd_size; +} + +static inline VkDeviceAddress vn_decode_vkGetBufferDeviceAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT); + + VkDeviceAddress ret; + vn_decode_VkDeviceAddress(dec, &ret); + /* skip device */ + /* skip pInfo */ + + return ret; +} + +static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_VkDevice(&device); + cmd_size += vn_sizeof_simple_pointer(pInfo); + if (pInfo) + cmd_size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(pInfo); + + return cmd_size; +} + +static inline void vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_VkDevice(enc, &device); + if (vn_encode_simple_pointer(enc, pInfo)) + vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(enc, pInfo); +} + +static inline size_t vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + uint64_t ret; + cmd_size += vn_sizeof_uint64_t(&ret); + /* skip device */ + /* skip pInfo */ + + return cmd_size; +} + +static inline uint64_t vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT); + + uint64_t ret; + vn_decode_uint64_t(dec, &ret); + /* skip device */ + /* skip pInfo */ + + return ret; +} + +static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA(const VkCommandStreamDescriptionMESA* pStream) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_simple_pointer(pStream); + if (pStream) + cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(pStream); + + return cmd_size; +} + +static inline void vn_encode_vkSetReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + if (vn_encode_simple_pointer(enc, pStream)) + vn_encode_VkCommandStreamDescriptionMESA(enc, pStream); +} + +static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA_reply(const VkCommandStreamDescriptionMESA* pStream) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip pStream */ + + return cmd_size; +} + +static inline void vn_decode_vkSetReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, const VkCommandStreamDescriptionMESA* pStream) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT); + + /* skip pStream */ +} + +static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA(size_t position) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_size_t(&position); + + return cmd_size; +} + +static inline void vn_encode_vkSeekReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, size_t position) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_size_t(enc, &position); +} + +static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA_reply(size_t position) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip position */ + + return cmd_size; +} + +static inline void vn_decode_vkSeekReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, size_t position) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT); + + /* skip position */ +} + +static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_uint32_t(&streamCount); + if (pStreams) { + cmd_size += vn_sizeof_array_size(streamCount); + for (uint32_t i = 0; i < streamCount; i++) + cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(&pStreams[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + if (pReplyPositions) { + cmd_size += vn_sizeof_array_size(streamCount); + cmd_size += vn_sizeof_size_t_array(pReplyPositions, streamCount); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_uint32_t(&dependencyCount); + if (pDependencies) { + cmd_size += vn_sizeof_array_size(dependencyCount); + for (uint32_t i = 0; i < dependencyCount; i++) + cmd_size += vn_sizeof_VkCommandStreamDependencyMESA(&pDependencies[i]); + } else { + cmd_size += vn_sizeof_array_size(0); + } + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkExecuteCommandStreamsMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_uint32_t(enc, &streamCount); + if (pStreams) { + vn_encode_array_size(enc, streamCount); + for (uint32_t i = 0; i < streamCount; i++) + vn_encode_VkCommandStreamDescriptionMESA(enc, &pStreams[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (pReplyPositions) { + vn_encode_array_size(enc, streamCount); + vn_encode_size_t_array(enc, pReplyPositions, streamCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &dependencyCount); + if (pDependencies) { + vn_encode_array_size(enc, dependencyCount); + for (uint32_t i = 0; i < dependencyCount; i++) + vn_encode_VkCommandStreamDependencyMESA(enc, &pDependencies[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA_reply(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip streamCount */ + /* skip pStreams */ + /* skip pReplyPositions */ + /* skip dependencyCount */ + /* skip pDependencies */ + /* skip flags */ + + return cmd_size; +} + +static inline void vn_decode_vkExecuteCommandStreamsMESA_reply(struct vn_cs_decoder *dec, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT); + + /* skip streamCount */ + /* skip pStreams */ + /* skip pReplyPositions */ + /* skip dependencyCount */ + /* skip pDependencies */ + /* skip flags */ +} + +static inline size_t vn_sizeof_vkCreateRingMESA(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_uint64_t(&ring); + cmd_size += vn_sizeof_simple_pointer(pCreateInfo); + if (pCreateInfo) + cmd_size += vn_sizeof_VkRingCreateInfoMESA(pCreateInfo); + + return cmd_size; +} + +static inline void vn_encode_vkCreateRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_uint64_t(enc, &ring); + if (vn_encode_simple_pointer(enc, pCreateInfo)) + vn_encode_VkRingCreateInfoMESA(enc, pCreateInfo); +} + +static inline size_t vn_sizeof_vkCreateRingMESA_reply(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip ring */ + /* skip pCreateInfo */ + + return cmd_size; +} + +static inline void vn_decode_vkCreateRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkCreateRingMESA_EXT); + + /* skip ring */ + /* skip pCreateInfo */ +} + +static inline size_t vn_sizeof_vkDestroyRingMESA(uint64_t ring) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_uint64_t(&ring); + + return cmd_size; +} + +static inline void vn_encode_vkDestroyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_uint64_t(enc, &ring); +} + +static inline size_t vn_sizeof_vkDestroyRingMESA_reply(uint64_t ring) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip ring */ + + return cmd_size; +} + +static inline void vn_decode_vkDestroyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkDestroyRingMESA_EXT); + + /* skip ring */ +} + +static inline size_t vn_sizeof_vkNotifyRingMESA(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_uint64_t(&ring); + cmd_size += vn_sizeof_uint32_t(&seqno); + cmd_size += vn_sizeof_VkFlags(&flags); + + return cmd_size; +} + +static inline void vn_encode_vkNotifyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_uint64_t(enc, &ring); + vn_encode_uint32_t(enc, &seqno); + vn_encode_VkFlags(enc, &flags); +} + +static inline size_t vn_sizeof_vkNotifyRingMESA_reply(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip ring */ + /* skip seqno */ + /* skip flags */ + + return cmd_size; +} + +static inline void vn_decode_vkNotifyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkNotifyRingMESA_EXT); + + /* skip ring */ + /* skip seqno */ + /* skip flags */ +} + +static inline size_t vn_sizeof_vkWriteRingExtraMESA(uint64_t ring, size_t offset, uint32_t value) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT; + const VkFlags cmd_flags = 0; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags); + + cmd_size += vn_sizeof_uint64_t(&ring); + cmd_size += vn_sizeof_size_t(&offset); + cmd_size += vn_sizeof_uint32_t(&value); + + return cmd_size; +} + +static inline void vn_encode_vkWriteRingExtraMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT; + + vn_encode_VkCommandTypeEXT(enc, &cmd_type); + vn_encode_VkFlags(enc, &cmd_flags); + + vn_encode_uint64_t(enc, &ring); + vn_encode_size_t(enc, &offset); + vn_encode_uint32_t(enc, &value); +} + +static inline size_t vn_sizeof_vkWriteRingExtraMESA_reply(uint64_t ring, size_t offset, uint32_t value) +{ + const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT; + size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type); + + /* skip ring */ + /* skip offset */ + /* skip value */ + + return cmd_size; +} + +static inline void vn_decode_vkWriteRingExtraMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, size_t offset, uint32_t value) +{ + VkCommandTypeEXT command_type; + vn_decode_VkCommandTypeEXT(dec, &command_type); + assert(command_type == VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT); + + /* skip ring */ + /* skip offset */ + /* skip value */ +} + +#endif /* VN_PROTOCOL_DRIVER_COMMANDS_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_cs.h b/src/virtio/venus-protocol/vn_protocol_driver_cs.h new file mode 100644 index 00000000000..fa63ab6e359 --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_cs.h @@ -0,0 +1,46 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_CS_H +#define VN_PROTOCOL_DRIVER_CS_H + +#include + +/* + * These types/functions are expected + * + * struct vn_cs_encoder + * vn_cs_encoder_get_len + * vn_cs_encoder_reserve + * vn_cs_encoder_write + * + * struct vn_cs_decoder + * vn_cs_decoder_set_fatal + * vn_cs_decoder_read + * vn_cs_decoder_peek + * + * vn_cs_handle_load_id + * vn_cs_handle_store_id + */ +#include "vn_cs.h" + +static inline void +vn_encode(struct vn_cs_encoder *enc, size_t size, const void *data, size_t data_size) +{ + assert(size % 4 == 0); + /* TODO check if the generated code is optimal */ + vn_cs_encoder_write(enc, size, data, data_size); +} + +static inline void +vn_decode(struct vn_cs_decoder *dec, size_t size, void *data, size_t data_size) +{ + assert(size % 4 == 0); + vn_cs_decoder_read(dec, size, data, data_size); +} + +#endif /* VN_PROTOCOL_DRIVER_CS_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_defines.h b/src/virtio/venus-protocol/vn_protocol_driver_defines.h new file mode 100644 index 00000000000..546a81f79b2 --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_defines.h @@ -0,0 +1,297 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_DEFINES_H +#define VN_PROTOCOL_DRIVER_DEFINES_H + +#include +#include +#include + +#include "vn_protocol_driver_cs.h" + +/* VkStructureType */ +#define VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA ((VkStructureType)1000384000) + +typedef enum VkCommandTypeEXT { + VK_COMMAND_TYPE_vkCreateInstance_EXT = 0, + VK_COMMAND_TYPE_vkDestroyInstance_EXT = 1, + VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT = 2, + VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT = 3, + VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT = 4, + VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT = 5, + VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT = 6, + VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT = 7, + VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT = 8, + VK_COMMAND_TYPE_vkGetInstanceProcAddr_EXT = 9, + VK_COMMAND_TYPE_vkGetDeviceProcAddr_EXT = 10, + VK_COMMAND_TYPE_vkCreateDevice_EXT = 11, + VK_COMMAND_TYPE_vkDestroyDevice_EXT = 12, + VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT = 13, + VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT = 14, + VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT = 15, + VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT = 16, + VK_COMMAND_TYPE_vkGetDeviceQueue_EXT = 17, + VK_COMMAND_TYPE_vkQueueSubmit_EXT = 18, + VK_COMMAND_TYPE_vkQueueWaitIdle_EXT = 19, + VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT = 20, + VK_COMMAND_TYPE_vkAllocateMemory_EXT = 21, + VK_COMMAND_TYPE_vkFreeMemory_EXT = 22, + VK_COMMAND_TYPE_vkMapMemory_EXT = 23, + VK_COMMAND_TYPE_vkUnmapMemory_EXT = 24, + VK_COMMAND_TYPE_vkFlushMappedMemoryRanges_EXT = 25, + VK_COMMAND_TYPE_vkInvalidateMappedMemoryRanges_EXT = 26, + VK_COMMAND_TYPE_vkGetDeviceMemoryCommitment_EXT = 27, + VK_COMMAND_TYPE_vkBindBufferMemory_EXT = 28, + VK_COMMAND_TYPE_vkBindImageMemory_EXT = 29, + VK_COMMAND_TYPE_vkGetBufferMemoryRequirements_EXT = 30, + VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT = 31, + VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT = 32, + VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT = 33, + VK_COMMAND_TYPE_vkQueueBindSparse_EXT = 34, + VK_COMMAND_TYPE_vkCreateFence_EXT = 35, + VK_COMMAND_TYPE_vkDestroyFence_EXT = 36, + VK_COMMAND_TYPE_vkResetFences_EXT = 37, + VK_COMMAND_TYPE_vkGetFenceStatus_EXT = 38, + VK_COMMAND_TYPE_vkWaitForFences_EXT = 39, + VK_COMMAND_TYPE_vkCreateSemaphore_EXT = 40, + VK_COMMAND_TYPE_vkDestroySemaphore_EXT = 41, + VK_COMMAND_TYPE_vkCreateEvent_EXT = 42, + VK_COMMAND_TYPE_vkDestroyEvent_EXT = 43, + VK_COMMAND_TYPE_vkGetEventStatus_EXT = 44, + VK_COMMAND_TYPE_vkSetEvent_EXT = 45, + VK_COMMAND_TYPE_vkResetEvent_EXT = 46, + VK_COMMAND_TYPE_vkCreateQueryPool_EXT = 47, + VK_COMMAND_TYPE_vkDestroyQueryPool_EXT = 48, + VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT = 49, + VK_COMMAND_TYPE_vkCreateBuffer_EXT = 50, + VK_COMMAND_TYPE_vkDestroyBuffer_EXT = 51, + VK_COMMAND_TYPE_vkCreateBufferView_EXT = 52, + VK_COMMAND_TYPE_vkDestroyBufferView_EXT = 53, + VK_COMMAND_TYPE_vkCreateImage_EXT = 54, + VK_COMMAND_TYPE_vkDestroyImage_EXT = 55, + VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT = 56, + VK_COMMAND_TYPE_vkCreateImageView_EXT = 57, + VK_COMMAND_TYPE_vkDestroyImageView_EXT = 58, + VK_COMMAND_TYPE_vkCreateShaderModule_EXT = 59, + VK_COMMAND_TYPE_vkDestroyShaderModule_EXT = 60, + VK_COMMAND_TYPE_vkCreatePipelineCache_EXT = 61, + VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT = 62, + VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT = 63, + VK_COMMAND_TYPE_vkMergePipelineCaches_EXT = 64, + VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT = 65, + VK_COMMAND_TYPE_vkCreateComputePipelines_EXT = 66, + VK_COMMAND_TYPE_vkDestroyPipeline_EXT = 67, + VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT = 68, + VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT = 69, + VK_COMMAND_TYPE_vkCreateSampler_EXT = 70, + VK_COMMAND_TYPE_vkDestroySampler_EXT = 71, + VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT = 72, + VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT = 73, + VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT = 74, + VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT = 75, + VK_COMMAND_TYPE_vkResetDescriptorPool_EXT = 76, + VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT = 77, + VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT = 78, + VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT = 79, + VK_COMMAND_TYPE_vkCreateFramebuffer_EXT = 80, + VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT = 81, + VK_COMMAND_TYPE_vkCreateRenderPass_EXT = 82, + VK_COMMAND_TYPE_vkDestroyRenderPass_EXT = 83, + VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT = 84, + VK_COMMAND_TYPE_vkCreateCommandPool_EXT = 85, + VK_COMMAND_TYPE_vkDestroyCommandPool_EXT = 86, + VK_COMMAND_TYPE_vkResetCommandPool_EXT = 87, + VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT = 88, + VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT = 89, + VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT = 90, + VK_COMMAND_TYPE_vkEndCommandBuffer_EXT = 91, + VK_COMMAND_TYPE_vkResetCommandBuffer_EXT = 92, + VK_COMMAND_TYPE_vkCmdBindPipeline_EXT = 93, + VK_COMMAND_TYPE_vkCmdSetViewport_EXT = 94, + VK_COMMAND_TYPE_vkCmdSetScissor_EXT = 95, + VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT = 96, + VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT = 97, + VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT = 98, + VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT = 99, + VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT = 100, + VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT = 101, + VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT = 102, + VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT = 103, + VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT = 104, + VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT = 105, + VK_COMMAND_TYPE_vkCmdDraw_EXT = 106, + VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT = 107, + VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT = 108, + VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT = 109, + VK_COMMAND_TYPE_vkCmdDispatch_EXT = 110, + VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT = 111, + VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT = 112, + VK_COMMAND_TYPE_vkCmdCopyImage_EXT = 113, + VK_COMMAND_TYPE_vkCmdBlitImage_EXT = 114, + VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT = 115, + VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT = 116, + VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT = 117, + VK_COMMAND_TYPE_vkCmdFillBuffer_EXT = 118, + VK_COMMAND_TYPE_vkCmdClearColorImage_EXT = 119, + VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT = 120, + VK_COMMAND_TYPE_vkCmdClearAttachments_EXT = 121, + VK_COMMAND_TYPE_vkCmdResolveImage_EXT = 122, + VK_COMMAND_TYPE_vkCmdSetEvent_EXT = 123, + VK_COMMAND_TYPE_vkCmdResetEvent_EXT = 124, + VK_COMMAND_TYPE_vkCmdWaitEvents_EXT = 125, + VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT = 126, + VK_COMMAND_TYPE_vkCmdBeginQuery_EXT = 127, + VK_COMMAND_TYPE_vkCmdEndQuery_EXT = 128, + VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT = 129, + VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT = 130, + VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT = 131, + VK_COMMAND_TYPE_vkCmdPushConstants_EXT = 132, + VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT = 133, + VK_COMMAND_TYPE_vkCmdNextSubpass_EXT = 134, + VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT = 135, + VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT = 136, + VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT = 137, + VK_COMMAND_TYPE_vkBindBufferMemory2_EXT = 138, + VK_COMMAND_TYPE_vkBindBufferMemory2KHR_EXT = 138, + VK_COMMAND_TYPE_vkBindImageMemory2_EXT = 139, + VK_COMMAND_TYPE_vkBindImageMemory2KHR_EXT = 139, + VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT = 140, + VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeaturesKHR_EXT = 140, + VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT = 141, + VK_COMMAND_TYPE_vkCmdSetDeviceMaskKHR_EXT = 141, + VK_COMMAND_TYPE_vkCmdDispatchBase_EXT = 142, + VK_COMMAND_TYPE_vkCmdDispatchBaseKHR_EXT = 142, + VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT = 143, + VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroupsKHR_EXT = 143, + VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT = 144, + VK_COMMAND_TYPE_vkGetImageMemoryRequirements2KHR_EXT = 144, + VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT = 145, + VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2KHR_EXT = 145, + VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT = 146, + VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2KHR_EXT = 146, + VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT = 147, + VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2KHR_EXT = 147, + VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT = 148, + VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2KHR_EXT = 148, + VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT = 149, + VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2KHR_EXT = 149, + VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT = 150, + VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2KHR_EXT = 150, + VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT = 151, + VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2KHR_EXT = 151, + VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT = 152, + VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2KHR_EXT = 152, + VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT = 153, + VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_EXT = 153, + VK_COMMAND_TYPE_vkTrimCommandPool_EXT = 154, + VK_COMMAND_TYPE_vkTrimCommandPoolKHR_EXT = 154, + VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT = 155, + VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT = 156, + VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversionKHR_EXT = 156, + VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT = 157, + VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversionKHR_EXT = 157, + VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT = 158, + VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplateKHR_EXT = 158, + VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT = 159, + VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplateKHR_EXT = 159, + VK_COMMAND_TYPE_vkUpdateDescriptorSetWithTemplate_EXT = 160, + VK_COMMAND_TYPE_vkUpdateDescriptorSetWithTemplateKHR_EXT = 160, + VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT = 161, + VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferPropertiesKHR_EXT = 161, + VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT = 162, + VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFencePropertiesKHR_EXT = 162, + VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT = 163, + VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_EXT = 163, + VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT = 164, + VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupportKHR_EXT = 164, + VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT = 165, + VK_COMMAND_TYPE_vkCmdDrawIndirectCountKHR_EXT = 165, + VK_COMMAND_TYPE_vkCmdDrawIndirectCountAMD_EXT = 165, + VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT = 166, + VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCountKHR_EXT = 166, + VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCountAMD_EXT = 166, + VK_COMMAND_TYPE_vkCreateRenderPass2_EXT = 167, + VK_COMMAND_TYPE_vkCreateRenderPass2KHR_EXT = 167, + VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT = 168, + VK_COMMAND_TYPE_vkCmdBeginRenderPass2KHR_EXT = 168, + VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT = 169, + VK_COMMAND_TYPE_vkCmdNextSubpass2KHR_EXT = 169, + VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT = 170, + VK_COMMAND_TYPE_vkCmdEndRenderPass2KHR_EXT = 170, + VK_COMMAND_TYPE_vkResetQueryPool_EXT = 171, + VK_COMMAND_TYPE_vkResetQueryPoolEXT_EXT = 171, + VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT = 172, + VK_COMMAND_TYPE_vkGetSemaphoreCounterValueKHR_EXT = 172, + VK_COMMAND_TYPE_vkWaitSemaphores_EXT = 173, + VK_COMMAND_TYPE_vkWaitSemaphoresKHR_EXT = 173, + VK_COMMAND_TYPE_vkSignalSemaphore_EXT = 174, + VK_COMMAND_TYPE_vkSignalSemaphoreKHR_EXT = 174, + VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT = 175, + VK_COMMAND_TYPE_vkGetBufferDeviceAddressKHR_EXT = 175, + VK_COMMAND_TYPE_vkGetBufferDeviceAddressEXT_EXT = 175, + VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT = 176, + VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddressKHR_EXT = 176, + VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT = 177, + VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddressKHR_EXT = 177, + VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT = 181, + VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT = 182, + VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT = 183, + VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT = 184, + VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT = 185, + VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT = 186, + VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT = 187, + VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT = 178, + VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT = 179, + VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT = 180, + VK_COMMAND_TYPE_vkCreateRingMESA_EXT = 188, + VK_COMMAND_TYPE_vkDestroyRingMESA_EXT = 189, + VK_COMMAND_TYPE_vkNotifyRingMESA_EXT = 190, + VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT = 191, +} VkCommandTypeEXT; + +typedef enum VkCommandFlagBitsEXT { + VK_COMMAND_GENERATE_REPLY_BIT_EXT = 0x00000001, +} VkCommandFlagBitsEXT; + +typedef VkFlags VkCommandFlagsEXT; + +typedef VkFlags VkCommandStreamExecutionFlagsMESA; + +typedef VkFlags VkRingCreateFlagsMESA; + +typedef VkFlags VkRingNotifyFlagsMESA; + +typedef struct VkCommandStreamDescriptionMESA { + uint32_t resourceId; + size_t offset; + size_t size; +} VkCommandStreamDescriptionMESA; + +typedef struct VkCommandStreamDependencyMESA { + uint32_t srcCommandStream; + uint32_t dstCommandStream; +} VkCommandStreamDependencyMESA; + +typedef struct VkRingCreateInfoMESA { + VkStructureType sType; + const void* pNext; + VkRingCreateFlagsMESA flags; + uint32_t resourceId; + size_t offset; + size_t size; + uint64_t idleTimeout; + size_t headOffset; + size_t tailOffset; + size_t statusOffset; + size_t bufferOffset; + size_t bufferSize; + size_t extraOffset; + size_t extraSize; +} VkRingCreateInfoMESA; + +#endif /* VN_PROTOCOL_DRIVER_DEFINES_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_handles.h b/src/virtio/venus-protocol/vn_protocol_driver_handles.h new file mode 100644 index 00000000000..01c773f831b --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_handles.h @@ -0,0 +1,634 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_HANDLES_H +#define VN_PROTOCOL_DRIVER_HANDLES_H + +#include "vn_protocol_driver_types.h" + +/* VK_DEFINE_HANDLE(VkInstance) */ + +static inline size_t +vn_sizeof_VkInstance(const VkInstance *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkInstance(struct vn_cs_encoder *enc, const VkInstance *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_INSTANCE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkInstance(struct vn_cs_decoder *dec, VkInstance *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_INSTANCE); +} + +/* VK_DEFINE_HANDLE(VkPhysicalDevice) */ + +static inline size_t +vn_sizeof_VkPhysicalDevice(const VkPhysicalDevice *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkPhysicalDevice(struct vn_cs_encoder *enc, const VkPhysicalDevice *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PHYSICAL_DEVICE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkPhysicalDevice(struct vn_cs_decoder *dec, VkPhysicalDevice *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PHYSICAL_DEVICE); +} + +/* VK_DEFINE_HANDLE(VkDevice) */ + +static inline size_t +vn_sizeof_VkDevice(const VkDevice *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkDevice(struct vn_cs_encoder *enc, const VkDevice *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_DEVICE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkDevice(struct vn_cs_decoder *dec, VkDevice *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_DEVICE); +} + +/* VK_DEFINE_HANDLE(VkQueue) */ + +static inline size_t +vn_sizeof_VkQueue(const VkQueue *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkQueue(struct vn_cs_encoder *enc, const VkQueue *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_QUEUE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkQueue(struct vn_cs_decoder *dec, VkQueue *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_QUEUE); +} + +/* VK_DEFINE_HANDLE(VkCommandBuffer) */ + +static inline size_t +vn_sizeof_VkCommandBuffer(const VkCommandBuffer *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkCommandBuffer(struct vn_cs_encoder *enc, const VkCommandBuffer *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_COMMAND_BUFFER); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkCommandBuffer(struct vn_cs_decoder *dec, VkCommandBuffer *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_COMMAND_BUFFER); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) */ + +static inline size_t +vn_sizeof_VkDeviceMemory(const VkDeviceMemory *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkDeviceMemory(struct vn_cs_encoder *enc, const VkDeviceMemory *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_DEVICE_MEMORY); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkDeviceMemory(struct vn_cs_decoder *dec, VkDeviceMemory *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_DEVICE_MEMORY); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) */ + +static inline size_t +vn_sizeof_VkCommandPool(const VkCommandPool *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkCommandPool(struct vn_cs_encoder *enc, const VkCommandPool *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_COMMAND_POOL); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkCommandPool(struct vn_cs_decoder *dec, VkCommandPool *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_COMMAND_POOL); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) */ + +static inline size_t +vn_sizeof_VkBuffer(const VkBuffer *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkBuffer(struct vn_cs_encoder *enc, const VkBuffer *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_BUFFER); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkBuffer(struct vn_cs_decoder *dec, VkBuffer *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_BUFFER); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) */ + +static inline size_t +vn_sizeof_VkBufferView(const VkBufferView *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkBufferView(struct vn_cs_encoder *enc, const VkBufferView *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_BUFFER_VIEW); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkBufferView(struct vn_cs_decoder *dec, VkBufferView *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_BUFFER_VIEW); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) */ + +static inline size_t +vn_sizeof_VkImage(const VkImage *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkImage(struct vn_cs_encoder *enc, const VkImage *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_IMAGE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkImage(struct vn_cs_decoder *dec, VkImage *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_IMAGE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) */ + +static inline size_t +vn_sizeof_VkImageView(const VkImageView *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkImageView(struct vn_cs_encoder *enc, const VkImageView *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_IMAGE_VIEW); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkImageView(struct vn_cs_decoder *dec, VkImageView *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_IMAGE_VIEW); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) */ + +static inline size_t +vn_sizeof_VkShaderModule(const VkShaderModule *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkShaderModule(struct vn_cs_encoder *enc, const VkShaderModule *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_SHADER_MODULE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkShaderModule(struct vn_cs_decoder *dec, VkShaderModule *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_SHADER_MODULE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) */ + +static inline size_t +vn_sizeof_VkPipeline(const VkPipeline *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkPipeline(struct vn_cs_encoder *enc, const VkPipeline *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PIPELINE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkPipeline(struct vn_cs_decoder *dec, VkPipeline *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PIPELINE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) */ + +static inline size_t +vn_sizeof_VkPipelineLayout(const VkPipelineLayout *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkPipelineLayout(struct vn_cs_encoder *enc, const VkPipelineLayout *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PIPELINE_LAYOUT); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkPipelineLayout(struct vn_cs_decoder *dec, VkPipelineLayout *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PIPELINE_LAYOUT); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) */ + +static inline size_t +vn_sizeof_VkSampler(const VkSampler *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkSampler(struct vn_cs_encoder *enc, const VkSampler *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_SAMPLER); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkSampler(struct vn_cs_decoder *dec, VkSampler *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_SAMPLER); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) */ + +static inline size_t +vn_sizeof_VkDescriptorSet(const VkDescriptorSet *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkDescriptorSet(struct vn_cs_encoder *enc, const VkDescriptorSet *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_DESCRIPTOR_SET); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkDescriptorSet(struct vn_cs_decoder *dec, VkDescriptorSet *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_DESCRIPTOR_SET); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) */ + +static inline size_t +vn_sizeof_VkDescriptorSetLayout(const VkDescriptorSetLayout *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkDescriptorSetLayout(struct vn_cs_encoder *enc, const VkDescriptorSetLayout *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkDescriptorSetLayout(struct vn_cs_decoder *dec, VkDescriptorSetLayout *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) */ + +static inline size_t +vn_sizeof_VkDescriptorPool(const VkDescriptorPool *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkDescriptorPool(struct vn_cs_encoder *enc, const VkDescriptorPool *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_DESCRIPTOR_POOL); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkDescriptorPool(struct vn_cs_decoder *dec, VkDescriptorPool *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_DESCRIPTOR_POOL); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) */ + +static inline size_t +vn_sizeof_VkFence(const VkFence *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkFence(struct vn_cs_encoder *enc, const VkFence *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_FENCE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkFence(struct vn_cs_decoder *dec, VkFence *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_FENCE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) */ + +static inline size_t +vn_sizeof_VkSemaphore(const VkSemaphore *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkSemaphore(struct vn_cs_encoder *enc, const VkSemaphore *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_SEMAPHORE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkSemaphore(struct vn_cs_decoder *dec, VkSemaphore *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_SEMAPHORE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) */ + +static inline size_t +vn_sizeof_VkEvent(const VkEvent *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkEvent(struct vn_cs_encoder *enc, const VkEvent *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_EVENT); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkEvent(struct vn_cs_decoder *dec, VkEvent *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_EVENT); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) */ + +static inline size_t +vn_sizeof_VkQueryPool(const VkQueryPool *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkQueryPool(struct vn_cs_encoder *enc, const VkQueryPool *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_QUERY_POOL); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkQueryPool(struct vn_cs_decoder *dec, VkQueryPool *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_QUERY_POOL); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) */ + +static inline size_t +vn_sizeof_VkFramebuffer(const VkFramebuffer *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkFramebuffer(struct vn_cs_encoder *enc, const VkFramebuffer *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_FRAMEBUFFER); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkFramebuffer(struct vn_cs_decoder *dec, VkFramebuffer *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_FRAMEBUFFER); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) */ + +static inline size_t +vn_sizeof_VkRenderPass(const VkRenderPass *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkRenderPass(struct vn_cs_encoder *enc, const VkRenderPass *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_RENDER_PASS); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkRenderPass(struct vn_cs_decoder *dec, VkRenderPass *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_RENDER_PASS); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) */ + +static inline size_t +vn_sizeof_VkPipelineCache(const VkPipelineCache *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkPipelineCache(struct vn_cs_encoder *enc, const VkPipelineCache *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PIPELINE_CACHE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkPipelineCache(struct vn_cs_decoder *dec, VkPipelineCache *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PIPELINE_CACHE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) */ + +static inline size_t +vn_sizeof_VkDescriptorUpdateTemplate(const VkDescriptorUpdateTemplate *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkDescriptorUpdateTemplate(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplate *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkDescriptorUpdateTemplate(struct vn_cs_decoder *dec, VkDescriptorUpdateTemplate *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE); +} + +/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) */ + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion *val) +{ + return sizeof(uint64_t); +} + +static inline void +vn_encode_VkSamplerYcbcrConversion(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversion *val) +{ + const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION); + vn_encode_uint64_t(enc, &id); +} + +static inline void +vn_decode_VkSamplerYcbcrConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrConversion *val) +{ + uint64_t id; + vn_decode_uint64_t(dec, &id); + vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION); +} + +#endif /* VN_PROTOCOL_DRIVER_HANDLES_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_info.h b/src/virtio/venus-protocol/vn_protocol_driver_info.h new file mode 100644 index 00000000000..f12d1770653 --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_info.h @@ -0,0 +1,149 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_INFO_H +#define VN_PROTOCOL_DRIVER_INFO_H + +#include "vn_protocol_driver_defines.h" + +static inline uint32_t +vn_info_wire_format_version(void) +{ + return 0; +} + +static inline uint32_t +vn_info_vk_xml_version(void) +{ + return VK_MAKE_VERSION(1, 2, 168); +} + +static inline int +vn_info_extension_compare(const void *a, const void *b) +{ + return strcmp(a, *(const char **)b); +} + +static inline uint32_t +vn_info_extension_spec_version(const char *name) +{ + static uint32_t ext_count = 51; + static const char *ext_names[51] = { + "VK_EXT_command_serialization", + "VK_EXT_descriptor_indexing", + "VK_EXT_host_query_reset", + "VK_EXT_image_drm_format_modifier", + "VK_EXT_sampler_filter_minmax", + "VK_EXT_scalar_block_layout", + "VK_EXT_separate_stencil_usage", + "VK_EXT_shader_viewport_index_layer", + "VK_EXT_transform_feedback", + "VK_KHR_16bit_storage", + "VK_KHR_8bit_storage", + "VK_KHR_bind_memory2", + "VK_KHR_buffer_device_address", + "VK_KHR_create_renderpass2", + "VK_KHR_dedicated_allocation", + "VK_KHR_depth_stencil_resolve", + "VK_KHR_descriptor_update_template", + "VK_KHR_device_group", + "VK_KHR_device_group_creation", + "VK_KHR_draw_indirect_count", + "VK_KHR_driver_properties", + "VK_KHR_external_fence", + "VK_KHR_external_fence_capabilities", + "VK_KHR_external_memory", + "VK_KHR_external_memory_capabilities", + "VK_KHR_external_semaphore", + "VK_KHR_external_semaphore_capabilities", + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_image_format_list", + "VK_KHR_imageless_framebuffer", + "VK_KHR_maintenance1", + "VK_KHR_maintenance2", + "VK_KHR_maintenance3", + "VK_KHR_multiview", + "VK_KHR_relaxed_block_layout", + "VK_KHR_sampler_mirror_clamp_to_edge", + "VK_KHR_sampler_ycbcr_conversion", + "VK_KHR_separate_depth_stencil_layouts", + "VK_KHR_shader_atomic_int64", + "VK_KHR_shader_draw_parameters", + "VK_KHR_shader_float16_int8", + "VK_KHR_shader_float_controls", + "VK_KHR_shader_subgroup_extended_types", + "VK_KHR_spirv_1_4", + "VK_KHR_storage_buffer_storage_class", + "VK_KHR_timeline_semaphore", + "VK_KHR_uniform_buffer_standard_layout", + "VK_KHR_variable_pointers", + "VK_KHR_vulkan_memory_model", + "VK_MESA_venus_protocol", + }; + static const uint32_t ext_versions[51] = { + 0, + 2, + 1, + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 3, + 1, + 1, + 4, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 1, + 1, + 2, + 1, + 1, + 1, + 1, + 3, + 14, + 1, + 1, + 1, + 1, + 4, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 0, + }; + const char **found; + + found = bsearch(name, ext_names, ext_count, sizeof(ext_names[0]), + vn_info_extension_compare); + + return found ? ext_versions[found - ext_names] : 0; +} + +#endif /* VN_PROTOCOL_DRIVER_INFO_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_structs.h b/src/virtio/venus-protocol/vn_protocol_driver_structs.h new file mode 100644 index 00000000000..2dfa6b1381f --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_structs.h @@ -0,0 +1,21466 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_STRUCTS_H +#define VN_PROTOCOL_DRIVER_STRUCTS_H + +#include "vn_protocol_driver_handles.h" + +/* + * These structs/unions are not included + * + * VkBaseOutStructure + * VkBaseInStructure + * VkAllocationCallbacks + */ + +/* struct VkOffset2D */ + +static inline size_t +vn_sizeof_VkOffset2D(const VkOffset2D *val) +{ + size_t size = 0; + size += vn_sizeof_int32_t(&val->x); + size += vn_sizeof_int32_t(&val->y); + return size; +} + +static inline void +vn_encode_VkOffset2D(struct vn_cs_encoder *enc, const VkOffset2D *val) +{ + vn_encode_int32_t(enc, &val->x); + vn_encode_int32_t(enc, &val->y); +} + +static inline void +vn_decode_VkOffset2D(struct vn_cs_decoder *dec, VkOffset2D *val) +{ + vn_decode_int32_t(dec, &val->x); + vn_decode_int32_t(dec, &val->y); +} + +static inline size_t +vn_sizeof_VkOffset2D_partial(const VkOffset2D *val) +{ + size_t size = 0; + /* skip val->x */ + /* skip val->y */ + return size; +} + +static inline void +vn_encode_VkOffset2D_partial(struct vn_cs_encoder *enc, const VkOffset2D *val) +{ + /* skip val->x */ + /* skip val->y */ +} + +/* struct VkOffset3D */ + +static inline size_t +vn_sizeof_VkOffset3D(const VkOffset3D *val) +{ + size_t size = 0; + size += vn_sizeof_int32_t(&val->x); + size += vn_sizeof_int32_t(&val->y); + size += vn_sizeof_int32_t(&val->z); + return size; +} + +static inline void +vn_encode_VkOffset3D(struct vn_cs_encoder *enc, const VkOffset3D *val) +{ + vn_encode_int32_t(enc, &val->x); + vn_encode_int32_t(enc, &val->y); + vn_encode_int32_t(enc, &val->z); +} + +/* struct VkExtent2D */ + +static inline size_t +vn_sizeof_VkExtent2D(const VkExtent2D *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->width); + size += vn_sizeof_uint32_t(&val->height); + return size; +} + +static inline void +vn_encode_VkExtent2D(struct vn_cs_encoder *enc, const VkExtent2D *val) +{ + vn_encode_uint32_t(enc, &val->width); + vn_encode_uint32_t(enc, &val->height); +} + +static inline void +vn_decode_VkExtent2D(struct vn_cs_decoder *dec, VkExtent2D *val) +{ + vn_decode_uint32_t(dec, &val->width); + vn_decode_uint32_t(dec, &val->height); +} + +static inline size_t +vn_sizeof_VkExtent2D_partial(const VkExtent2D *val) +{ + size_t size = 0; + /* skip val->width */ + /* skip val->height */ + return size; +} + +static inline void +vn_encode_VkExtent2D_partial(struct vn_cs_encoder *enc, const VkExtent2D *val) +{ + /* skip val->width */ + /* skip val->height */ +} + +/* struct VkExtent3D */ + +static inline size_t +vn_sizeof_VkExtent3D(const VkExtent3D *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->width); + size += vn_sizeof_uint32_t(&val->height); + size += vn_sizeof_uint32_t(&val->depth); + return size; +} + +static inline void +vn_encode_VkExtent3D(struct vn_cs_encoder *enc, const VkExtent3D *val) +{ + vn_encode_uint32_t(enc, &val->width); + vn_encode_uint32_t(enc, &val->height); + vn_encode_uint32_t(enc, &val->depth); +} + +static inline void +vn_decode_VkExtent3D(struct vn_cs_decoder *dec, VkExtent3D *val) +{ + vn_decode_uint32_t(dec, &val->width); + vn_decode_uint32_t(dec, &val->height); + vn_decode_uint32_t(dec, &val->depth); +} + +static inline size_t +vn_sizeof_VkExtent3D_partial(const VkExtent3D *val) +{ + size_t size = 0; + /* skip val->width */ + /* skip val->height */ + /* skip val->depth */ + return size; +} + +static inline void +vn_encode_VkExtent3D_partial(struct vn_cs_encoder *enc, const VkExtent3D *val) +{ + /* skip val->width */ + /* skip val->height */ + /* skip val->depth */ +} + +/* struct VkViewport */ + +static inline size_t +vn_sizeof_VkViewport(const VkViewport *val) +{ + size_t size = 0; + size += vn_sizeof_float(&val->x); + size += vn_sizeof_float(&val->y); + size += vn_sizeof_float(&val->width); + size += vn_sizeof_float(&val->height); + size += vn_sizeof_float(&val->minDepth); + size += vn_sizeof_float(&val->maxDepth); + return size; +} + +static inline void +vn_encode_VkViewport(struct vn_cs_encoder *enc, const VkViewport *val) +{ + vn_encode_float(enc, &val->x); + vn_encode_float(enc, &val->y); + vn_encode_float(enc, &val->width); + vn_encode_float(enc, &val->height); + vn_encode_float(enc, &val->minDepth); + vn_encode_float(enc, &val->maxDepth); +} + +/* struct VkRect2D */ + +static inline size_t +vn_sizeof_VkRect2D(const VkRect2D *val) +{ + size_t size = 0; + size += vn_sizeof_VkOffset2D(&val->offset); + size += vn_sizeof_VkExtent2D(&val->extent); + return size; +} + +static inline void +vn_encode_VkRect2D(struct vn_cs_encoder *enc, const VkRect2D *val) +{ + vn_encode_VkOffset2D(enc, &val->offset); + vn_encode_VkExtent2D(enc, &val->extent); +} + +static inline void +vn_decode_VkRect2D(struct vn_cs_decoder *dec, VkRect2D *val) +{ + vn_decode_VkOffset2D(dec, &val->offset); + vn_decode_VkExtent2D(dec, &val->extent); +} + +static inline size_t +vn_sizeof_VkRect2D_partial(const VkRect2D *val) +{ + size_t size = 0; + size += vn_sizeof_VkOffset2D_partial(&val->offset); + size += vn_sizeof_VkExtent2D_partial(&val->extent); + return size; +} + +static inline void +vn_encode_VkRect2D_partial(struct vn_cs_encoder *enc, const VkRect2D *val) +{ + vn_encode_VkOffset2D_partial(enc, &val->offset); + vn_encode_VkExtent2D_partial(enc, &val->extent); +} + +/* struct VkClearRect */ + +static inline size_t +vn_sizeof_VkClearRect(const VkClearRect *val) +{ + size_t size = 0; + size += vn_sizeof_VkRect2D(&val->rect); + size += vn_sizeof_uint32_t(&val->baseArrayLayer); + size += vn_sizeof_uint32_t(&val->layerCount); + return size; +} + +static inline void +vn_encode_VkClearRect(struct vn_cs_encoder *enc, const VkClearRect *val) +{ + vn_encode_VkRect2D(enc, &val->rect); + vn_encode_uint32_t(enc, &val->baseArrayLayer); + vn_encode_uint32_t(enc, &val->layerCount); +} + +/* struct VkComponentMapping */ + +static inline size_t +vn_sizeof_VkComponentMapping(const VkComponentMapping *val) +{ + size_t size = 0; + size += vn_sizeof_VkComponentSwizzle(&val->r); + size += vn_sizeof_VkComponentSwizzle(&val->g); + size += vn_sizeof_VkComponentSwizzle(&val->b); + size += vn_sizeof_VkComponentSwizzle(&val->a); + return size; +} + +static inline void +vn_encode_VkComponentMapping(struct vn_cs_encoder *enc, const VkComponentMapping *val) +{ + vn_encode_VkComponentSwizzle(enc, &val->r); + vn_encode_VkComponentSwizzle(enc, &val->g); + vn_encode_VkComponentSwizzle(enc, &val->b); + vn_encode_VkComponentSwizzle(enc, &val->a); +} + +static inline void +vn_decode_VkComponentMapping(struct vn_cs_decoder *dec, VkComponentMapping *val) +{ + vn_decode_VkComponentSwizzle(dec, &val->r); + vn_decode_VkComponentSwizzle(dec, &val->g); + vn_decode_VkComponentSwizzle(dec, &val->b); + vn_decode_VkComponentSwizzle(dec, &val->a); +} + +static inline size_t +vn_sizeof_VkComponentMapping_partial(const VkComponentMapping *val) +{ + size_t size = 0; + /* skip val->r */ + /* skip val->g */ + /* skip val->b */ + /* skip val->a */ + return size; +} + +static inline void +vn_encode_VkComponentMapping_partial(struct vn_cs_encoder *enc, const VkComponentMapping *val) +{ + /* skip val->r */ + /* skip val->g */ + /* skip val->b */ + /* skip val->a */ +} + +/* struct VkPhysicalDeviceLimits */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->maxImageDimension1D); + size += vn_sizeof_uint32_t(&val->maxImageDimension2D); + size += vn_sizeof_uint32_t(&val->maxImageDimension3D); + size += vn_sizeof_uint32_t(&val->maxImageDimensionCube); + size += vn_sizeof_uint32_t(&val->maxImageArrayLayers); + size += vn_sizeof_uint32_t(&val->maxTexelBufferElements); + size += vn_sizeof_uint32_t(&val->maxUniformBufferRange); + size += vn_sizeof_uint32_t(&val->maxStorageBufferRange); + size += vn_sizeof_uint32_t(&val->maxPushConstantsSize); + size += vn_sizeof_uint32_t(&val->maxMemoryAllocationCount); + size += vn_sizeof_uint32_t(&val->maxSamplerAllocationCount); + size += vn_sizeof_VkDeviceSize(&val->bufferImageGranularity); + size += vn_sizeof_VkDeviceSize(&val->sparseAddressSpaceSize); + size += vn_sizeof_uint32_t(&val->maxBoundDescriptorSets); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSamplers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUniformBuffers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageBuffers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSampledImages); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageImages); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInputAttachments); + size += vn_sizeof_uint32_t(&val->maxPerStageResources); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetSamplers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffersDynamic); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffersDynamic); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetSampledImages); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageImages); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetInputAttachments); + size += vn_sizeof_uint32_t(&val->maxVertexInputAttributes); + size += vn_sizeof_uint32_t(&val->maxVertexInputBindings); + size += vn_sizeof_uint32_t(&val->maxVertexInputAttributeOffset); + size += vn_sizeof_uint32_t(&val->maxVertexInputBindingStride); + size += vn_sizeof_uint32_t(&val->maxVertexOutputComponents); + size += vn_sizeof_uint32_t(&val->maxTessellationGenerationLevel); + size += vn_sizeof_uint32_t(&val->maxTessellationPatchSize); + size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexInputComponents); + size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexOutputComponents); + size += vn_sizeof_uint32_t(&val->maxTessellationControlPerPatchOutputComponents); + size += vn_sizeof_uint32_t(&val->maxTessellationControlTotalOutputComponents); + size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationInputComponents); + size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationOutputComponents); + size += vn_sizeof_uint32_t(&val->maxGeometryShaderInvocations); + size += vn_sizeof_uint32_t(&val->maxGeometryInputComponents); + size += vn_sizeof_uint32_t(&val->maxGeometryOutputComponents); + size += vn_sizeof_uint32_t(&val->maxGeometryOutputVertices); + size += vn_sizeof_uint32_t(&val->maxGeometryTotalOutputComponents); + size += vn_sizeof_uint32_t(&val->maxFragmentInputComponents); + size += vn_sizeof_uint32_t(&val->maxFragmentOutputAttachments); + size += vn_sizeof_uint32_t(&val->maxFragmentDualSrcAttachments); + size += vn_sizeof_uint32_t(&val->maxFragmentCombinedOutputResources); + size += vn_sizeof_uint32_t(&val->maxComputeSharedMemorySize); + size += vn_sizeof_array_size(3); + size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupCount, 3); + size += vn_sizeof_uint32_t(&val->maxComputeWorkGroupInvocations); + size += vn_sizeof_array_size(3); + size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupSize, 3); + size += vn_sizeof_uint32_t(&val->subPixelPrecisionBits); + size += vn_sizeof_uint32_t(&val->subTexelPrecisionBits); + size += vn_sizeof_uint32_t(&val->mipmapPrecisionBits); + size += vn_sizeof_uint32_t(&val->maxDrawIndexedIndexValue); + size += vn_sizeof_uint32_t(&val->maxDrawIndirectCount); + size += vn_sizeof_float(&val->maxSamplerLodBias); + size += vn_sizeof_float(&val->maxSamplerAnisotropy); + size += vn_sizeof_uint32_t(&val->maxViewports); + size += vn_sizeof_array_size(2); + size += vn_sizeof_uint32_t_array(val->maxViewportDimensions, 2); + size += vn_sizeof_array_size(2); + size += vn_sizeof_float_array(val->viewportBoundsRange, 2); + size += vn_sizeof_uint32_t(&val->viewportSubPixelBits); + size += vn_sizeof_size_t(&val->minMemoryMapAlignment); + size += vn_sizeof_VkDeviceSize(&val->minTexelBufferOffsetAlignment); + size += vn_sizeof_VkDeviceSize(&val->minUniformBufferOffsetAlignment); + size += vn_sizeof_VkDeviceSize(&val->minStorageBufferOffsetAlignment); + size += vn_sizeof_int32_t(&val->minTexelOffset); + size += vn_sizeof_uint32_t(&val->maxTexelOffset); + size += vn_sizeof_int32_t(&val->minTexelGatherOffset); + size += vn_sizeof_uint32_t(&val->maxTexelGatherOffset); + size += vn_sizeof_float(&val->minInterpolationOffset); + size += vn_sizeof_float(&val->maxInterpolationOffset); + size += vn_sizeof_uint32_t(&val->subPixelInterpolationOffsetBits); + size += vn_sizeof_uint32_t(&val->maxFramebufferWidth); + size += vn_sizeof_uint32_t(&val->maxFramebufferHeight); + size += vn_sizeof_uint32_t(&val->maxFramebufferLayers); + size += vn_sizeof_VkFlags(&val->framebufferColorSampleCounts); + size += vn_sizeof_VkFlags(&val->framebufferDepthSampleCounts); + size += vn_sizeof_VkFlags(&val->framebufferStencilSampleCounts); + size += vn_sizeof_VkFlags(&val->framebufferNoAttachmentsSampleCounts); + size += vn_sizeof_uint32_t(&val->maxColorAttachments); + size += vn_sizeof_VkFlags(&val->sampledImageColorSampleCounts); + size += vn_sizeof_VkFlags(&val->sampledImageIntegerSampleCounts); + size += vn_sizeof_VkFlags(&val->sampledImageDepthSampleCounts); + size += vn_sizeof_VkFlags(&val->sampledImageStencilSampleCounts); + size += vn_sizeof_VkFlags(&val->storageImageSampleCounts); + size += vn_sizeof_uint32_t(&val->maxSampleMaskWords); + size += vn_sizeof_VkBool32(&val->timestampComputeAndGraphics); + size += vn_sizeof_float(&val->timestampPeriod); + size += vn_sizeof_uint32_t(&val->maxClipDistances); + size += vn_sizeof_uint32_t(&val->maxCullDistances); + size += vn_sizeof_uint32_t(&val->maxCombinedClipAndCullDistances); + size += vn_sizeof_uint32_t(&val->discreteQueuePriorities); + size += vn_sizeof_array_size(2); + size += vn_sizeof_float_array(val->pointSizeRange, 2); + size += vn_sizeof_array_size(2); + size += vn_sizeof_float_array(val->lineWidthRange, 2); + size += vn_sizeof_float(&val->pointSizeGranularity); + size += vn_sizeof_float(&val->lineWidthGranularity); + size += vn_sizeof_VkBool32(&val->strictLines); + size += vn_sizeof_VkBool32(&val->standardSampleLocations); + size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyOffsetAlignment); + size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyRowPitchAlignment); + size += vn_sizeof_VkDeviceSize(&val->nonCoherentAtomSize); + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder *dec, VkPhysicalDeviceLimits *val) +{ + vn_decode_uint32_t(dec, &val->maxImageDimension1D); + vn_decode_uint32_t(dec, &val->maxImageDimension2D); + vn_decode_uint32_t(dec, &val->maxImageDimension3D); + vn_decode_uint32_t(dec, &val->maxImageDimensionCube); + vn_decode_uint32_t(dec, &val->maxImageArrayLayers); + vn_decode_uint32_t(dec, &val->maxTexelBufferElements); + vn_decode_uint32_t(dec, &val->maxUniformBufferRange); + vn_decode_uint32_t(dec, &val->maxStorageBufferRange); + vn_decode_uint32_t(dec, &val->maxPushConstantsSize); + vn_decode_uint32_t(dec, &val->maxMemoryAllocationCount); + vn_decode_uint32_t(dec, &val->maxSamplerAllocationCount); + vn_decode_VkDeviceSize(dec, &val->bufferImageGranularity); + vn_decode_VkDeviceSize(dec, &val->sparseAddressSpaceSize); + vn_decode_uint32_t(dec, &val->maxBoundDescriptorSets); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSamplers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUniformBuffers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageBuffers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSampledImages); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageImages); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInputAttachments); + vn_decode_uint32_t(dec, &val->maxPerStageResources); + vn_decode_uint32_t(dec, &val->maxDescriptorSetSamplers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffersDynamic); + vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffersDynamic); + vn_decode_uint32_t(dec, &val->maxDescriptorSetSampledImages); + vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageImages); + vn_decode_uint32_t(dec, &val->maxDescriptorSetInputAttachments); + vn_decode_uint32_t(dec, &val->maxVertexInputAttributes); + vn_decode_uint32_t(dec, &val->maxVertexInputBindings); + vn_decode_uint32_t(dec, &val->maxVertexInputAttributeOffset); + vn_decode_uint32_t(dec, &val->maxVertexInputBindingStride); + vn_decode_uint32_t(dec, &val->maxVertexOutputComponents); + vn_decode_uint32_t(dec, &val->maxTessellationGenerationLevel); + vn_decode_uint32_t(dec, &val->maxTessellationPatchSize); + vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexInputComponents); + vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexOutputComponents); + vn_decode_uint32_t(dec, &val->maxTessellationControlPerPatchOutputComponents); + vn_decode_uint32_t(dec, &val->maxTessellationControlTotalOutputComponents); + vn_decode_uint32_t(dec, &val->maxTessellationEvaluationInputComponents); + vn_decode_uint32_t(dec, &val->maxTessellationEvaluationOutputComponents); + vn_decode_uint32_t(dec, &val->maxGeometryShaderInvocations); + vn_decode_uint32_t(dec, &val->maxGeometryInputComponents); + vn_decode_uint32_t(dec, &val->maxGeometryOutputComponents); + vn_decode_uint32_t(dec, &val->maxGeometryOutputVertices); + vn_decode_uint32_t(dec, &val->maxGeometryTotalOutputComponents); + vn_decode_uint32_t(dec, &val->maxFragmentInputComponents); + vn_decode_uint32_t(dec, &val->maxFragmentOutputAttachments); + vn_decode_uint32_t(dec, &val->maxFragmentDualSrcAttachments); + vn_decode_uint32_t(dec, &val->maxFragmentCombinedOutputResources); + vn_decode_uint32_t(dec, &val->maxComputeSharedMemorySize); + { + const size_t array_size = vn_decode_array_size(dec, 3); + vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupCount, array_size); + } + vn_decode_uint32_t(dec, &val->maxComputeWorkGroupInvocations); + { + const size_t array_size = vn_decode_array_size(dec, 3); + vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupSize, array_size); + } + vn_decode_uint32_t(dec, &val->subPixelPrecisionBits); + vn_decode_uint32_t(dec, &val->subTexelPrecisionBits); + vn_decode_uint32_t(dec, &val->mipmapPrecisionBits); + vn_decode_uint32_t(dec, &val->maxDrawIndexedIndexValue); + vn_decode_uint32_t(dec, &val->maxDrawIndirectCount); + vn_decode_float(dec, &val->maxSamplerLodBias); + vn_decode_float(dec, &val->maxSamplerAnisotropy); + vn_decode_uint32_t(dec, &val->maxViewports); + { + const size_t array_size = vn_decode_array_size(dec, 2); + vn_decode_uint32_t_array(dec, val->maxViewportDimensions, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, 2); + vn_decode_float_array(dec, val->viewportBoundsRange, array_size); + } + vn_decode_uint32_t(dec, &val->viewportSubPixelBits); + vn_decode_size_t(dec, &val->minMemoryMapAlignment); + vn_decode_VkDeviceSize(dec, &val->minTexelBufferOffsetAlignment); + vn_decode_VkDeviceSize(dec, &val->minUniformBufferOffsetAlignment); + vn_decode_VkDeviceSize(dec, &val->minStorageBufferOffsetAlignment); + vn_decode_int32_t(dec, &val->minTexelOffset); + vn_decode_uint32_t(dec, &val->maxTexelOffset); + vn_decode_int32_t(dec, &val->minTexelGatherOffset); + vn_decode_uint32_t(dec, &val->maxTexelGatherOffset); + vn_decode_float(dec, &val->minInterpolationOffset); + vn_decode_float(dec, &val->maxInterpolationOffset); + vn_decode_uint32_t(dec, &val->subPixelInterpolationOffsetBits); + vn_decode_uint32_t(dec, &val->maxFramebufferWidth); + vn_decode_uint32_t(dec, &val->maxFramebufferHeight); + vn_decode_uint32_t(dec, &val->maxFramebufferLayers); + vn_decode_VkFlags(dec, &val->framebufferColorSampleCounts); + vn_decode_VkFlags(dec, &val->framebufferDepthSampleCounts); + vn_decode_VkFlags(dec, &val->framebufferStencilSampleCounts); + vn_decode_VkFlags(dec, &val->framebufferNoAttachmentsSampleCounts); + vn_decode_uint32_t(dec, &val->maxColorAttachments); + vn_decode_VkFlags(dec, &val->sampledImageColorSampleCounts); + vn_decode_VkFlags(dec, &val->sampledImageIntegerSampleCounts); + vn_decode_VkFlags(dec, &val->sampledImageDepthSampleCounts); + vn_decode_VkFlags(dec, &val->sampledImageStencilSampleCounts); + vn_decode_VkFlags(dec, &val->storageImageSampleCounts); + vn_decode_uint32_t(dec, &val->maxSampleMaskWords); + vn_decode_VkBool32(dec, &val->timestampComputeAndGraphics); + vn_decode_float(dec, &val->timestampPeriod); + vn_decode_uint32_t(dec, &val->maxClipDistances); + vn_decode_uint32_t(dec, &val->maxCullDistances); + vn_decode_uint32_t(dec, &val->maxCombinedClipAndCullDistances); + vn_decode_uint32_t(dec, &val->discreteQueuePriorities); + { + const size_t array_size = vn_decode_array_size(dec, 2); + vn_decode_float_array(dec, val->pointSizeRange, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, 2); + vn_decode_float_array(dec, val->lineWidthRange, array_size); + } + vn_decode_float(dec, &val->pointSizeGranularity); + vn_decode_float(dec, &val->lineWidthGranularity); + vn_decode_VkBool32(dec, &val->strictLines); + vn_decode_VkBool32(dec, &val->standardSampleLocations); + vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyOffsetAlignment); + vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyRowPitchAlignment); + vn_decode_VkDeviceSize(dec, &val->nonCoherentAtomSize); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits *val) +{ + size_t size = 0; + /* skip val->maxImageDimension1D */ + /* skip val->maxImageDimension2D */ + /* skip val->maxImageDimension3D */ + /* skip val->maxImageDimensionCube */ + /* skip val->maxImageArrayLayers */ + /* skip val->maxTexelBufferElements */ + /* skip val->maxUniformBufferRange */ + /* skip val->maxStorageBufferRange */ + /* skip val->maxPushConstantsSize */ + /* skip val->maxMemoryAllocationCount */ + /* skip val->maxSamplerAllocationCount */ + /* skip val->bufferImageGranularity */ + /* skip val->sparseAddressSpaceSize */ + /* skip val->maxBoundDescriptorSets */ + /* skip val->maxPerStageDescriptorSamplers */ + /* skip val->maxPerStageDescriptorUniformBuffers */ + /* skip val->maxPerStageDescriptorStorageBuffers */ + /* skip val->maxPerStageDescriptorSampledImages */ + /* skip val->maxPerStageDescriptorStorageImages */ + /* skip val->maxPerStageDescriptorInputAttachments */ + /* skip val->maxPerStageResources */ + /* skip val->maxDescriptorSetSamplers */ + /* skip val->maxDescriptorSetUniformBuffers */ + /* skip val->maxDescriptorSetUniformBuffersDynamic */ + /* skip val->maxDescriptorSetStorageBuffers */ + /* skip val->maxDescriptorSetStorageBuffersDynamic */ + /* skip val->maxDescriptorSetSampledImages */ + /* skip val->maxDescriptorSetStorageImages */ + /* skip val->maxDescriptorSetInputAttachments */ + /* skip val->maxVertexInputAttributes */ + /* skip val->maxVertexInputBindings */ + /* skip val->maxVertexInputAttributeOffset */ + /* skip val->maxVertexInputBindingStride */ + /* skip val->maxVertexOutputComponents */ + /* skip val->maxTessellationGenerationLevel */ + /* skip val->maxTessellationPatchSize */ + /* skip val->maxTessellationControlPerVertexInputComponents */ + /* skip val->maxTessellationControlPerVertexOutputComponents */ + /* skip val->maxTessellationControlPerPatchOutputComponents */ + /* skip val->maxTessellationControlTotalOutputComponents */ + /* skip val->maxTessellationEvaluationInputComponents */ + /* skip val->maxTessellationEvaluationOutputComponents */ + /* skip val->maxGeometryShaderInvocations */ + /* skip val->maxGeometryInputComponents */ + /* skip val->maxGeometryOutputComponents */ + /* skip val->maxGeometryOutputVertices */ + /* skip val->maxGeometryTotalOutputComponents */ + /* skip val->maxFragmentInputComponents */ + /* skip val->maxFragmentOutputAttachments */ + /* skip val->maxFragmentDualSrcAttachments */ + /* skip val->maxFragmentCombinedOutputResources */ + /* skip val->maxComputeSharedMemorySize */ + /* skip val->maxComputeWorkGroupCount */ + /* skip val->maxComputeWorkGroupInvocations */ + /* skip val->maxComputeWorkGroupSize */ + /* skip val->subPixelPrecisionBits */ + /* skip val->subTexelPrecisionBits */ + /* skip val->mipmapPrecisionBits */ + /* skip val->maxDrawIndexedIndexValue */ + /* skip val->maxDrawIndirectCount */ + /* skip val->maxSamplerLodBias */ + /* skip val->maxSamplerAnisotropy */ + /* skip val->maxViewports */ + /* skip val->maxViewportDimensions */ + /* skip val->viewportBoundsRange */ + /* skip val->viewportSubPixelBits */ + /* skip val->minMemoryMapAlignment */ + /* skip val->minTexelBufferOffsetAlignment */ + /* skip val->minUniformBufferOffsetAlignment */ + /* skip val->minStorageBufferOffsetAlignment */ + /* skip val->minTexelOffset */ + /* skip val->maxTexelOffset */ + /* skip val->minTexelGatherOffset */ + /* skip val->maxTexelGatherOffset */ + /* skip val->minInterpolationOffset */ + /* skip val->maxInterpolationOffset */ + /* skip val->subPixelInterpolationOffsetBits */ + /* skip val->maxFramebufferWidth */ + /* skip val->maxFramebufferHeight */ + /* skip val->maxFramebufferLayers */ + /* skip val->framebufferColorSampleCounts */ + /* skip val->framebufferDepthSampleCounts */ + /* skip val->framebufferStencilSampleCounts */ + /* skip val->framebufferNoAttachmentsSampleCounts */ + /* skip val->maxColorAttachments */ + /* skip val->sampledImageColorSampleCounts */ + /* skip val->sampledImageIntegerSampleCounts */ + /* skip val->sampledImageDepthSampleCounts */ + /* skip val->sampledImageStencilSampleCounts */ + /* skip val->storageImageSampleCounts */ + /* skip val->maxSampleMaskWords */ + /* skip val->timestampComputeAndGraphics */ + /* skip val->timestampPeriod */ + /* skip val->maxClipDistances */ + /* skip val->maxCullDistances */ + /* skip val->maxCombinedClipAndCullDistances */ + /* skip val->discreteQueuePriorities */ + /* skip val->pointSizeRange */ + /* skip val->lineWidthRange */ + /* skip val->pointSizeGranularity */ + /* skip val->lineWidthGranularity */ + /* skip val->strictLines */ + /* skip val->standardSampleLocations */ + /* skip val->optimalBufferCopyOffsetAlignment */ + /* skip val->optimalBufferCopyRowPitchAlignment */ + /* skip val->nonCoherentAtomSize */ + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLimits *val) +{ + /* skip val->maxImageDimension1D */ + /* skip val->maxImageDimension2D */ + /* skip val->maxImageDimension3D */ + /* skip val->maxImageDimensionCube */ + /* skip val->maxImageArrayLayers */ + /* skip val->maxTexelBufferElements */ + /* skip val->maxUniformBufferRange */ + /* skip val->maxStorageBufferRange */ + /* skip val->maxPushConstantsSize */ + /* skip val->maxMemoryAllocationCount */ + /* skip val->maxSamplerAllocationCount */ + /* skip val->bufferImageGranularity */ + /* skip val->sparseAddressSpaceSize */ + /* skip val->maxBoundDescriptorSets */ + /* skip val->maxPerStageDescriptorSamplers */ + /* skip val->maxPerStageDescriptorUniformBuffers */ + /* skip val->maxPerStageDescriptorStorageBuffers */ + /* skip val->maxPerStageDescriptorSampledImages */ + /* skip val->maxPerStageDescriptorStorageImages */ + /* skip val->maxPerStageDescriptorInputAttachments */ + /* skip val->maxPerStageResources */ + /* skip val->maxDescriptorSetSamplers */ + /* skip val->maxDescriptorSetUniformBuffers */ + /* skip val->maxDescriptorSetUniformBuffersDynamic */ + /* skip val->maxDescriptorSetStorageBuffers */ + /* skip val->maxDescriptorSetStorageBuffersDynamic */ + /* skip val->maxDescriptorSetSampledImages */ + /* skip val->maxDescriptorSetStorageImages */ + /* skip val->maxDescriptorSetInputAttachments */ + /* skip val->maxVertexInputAttributes */ + /* skip val->maxVertexInputBindings */ + /* skip val->maxVertexInputAttributeOffset */ + /* skip val->maxVertexInputBindingStride */ + /* skip val->maxVertexOutputComponents */ + /* skip val->maxTessellationGenerationLevel */ + /* skip val->maxTessellationPatchSize */ + /* skip val->maxTessellationControlPerVertexInputComponents */ + /* skip val->maxTessellationControlPerVertexOutputComponents */ + /* skip val->maxTessellationControlPerPatchOutputComponents */ + /* skip val->maxTessellationControlTotalOutputComponents */ + /* skip val->maxTessellationEvaluationInputComponents */ + /* skip val->maxTessellationEvaluationOutputComponents */ + /* skip val->maxGeometryShaderInvocations */ + /* skip val->maxGeometryInputComponents */ + /* skip val->maxGeometryOutputComponents */ + /* skip val->maxGeometryOutputVertices */ + /* skip val->maxGeometryTotalOutputComponents */ + /* skip val->maxFragmentInputComponents */ + /* skip val->maxFragmentOutputAttachments */ + /* skip val->maxFragmentDualSrcAttachments */ + /* skip val->maxFragmentCombinedOutputResources */ + /* skip val->maxComputeSharedMemorySize */ + /* skip val->maxComputeWorkGroupCount */ + /* skip val->maxComputeWorkGroupInvocations */ + /* skip val->maxComputeWorkGroupSize */ + /* skip val->subPixelPrecisionBits */ + /* skip val->subTexelPrecisionBits */ + /* skip val->mipmapPrecisionBits */ + /* skip val->maxDrawIndexedIndexValue */ + /* skip val->maxDrawIndirectCount */ + /* skip val->maxSamplerLodBias */ + /* skip val->maxSamplerAnisotropy */ + /* skip val->maxViewports */ + /* skip val->maxViewportDimensions */ + /* skip val->viewportBoundsRange */ + /* skip val->viewportSubPixelBits */ + /* skip val->minMemoryMapAlignment */ + /* skip val->minTexelBufferOffsetAlignment */ + /* skip val->minUniformBufferOffsetAlignment */ + /* skip val->minStorageBufferOffsetAlignment */ + /* skip val->minTexelOffset */ + /* skip val->maxTexelOffset */ + /* skip val->minTexelGatherOffset */ + /* skip val->maxTexelGatherOffset */ + /* skip val->minInterpolationOffset */ + /* skip val->maxInterpolationOffset */ + /* skip val->subPixelInterpolationOffsetBits */ + /* skip val->maxFramebufferWidth */ + /* skip val->maxFramebufferHeight */ + /* skip val->maxFramebufferLayers */ + /* skip val->framebufferColorSampleCounts */ + /* skip val->framebufferDepthSampleCounts */ + /* skip val->framebufferStencilSampleCounts */ + /* skip val->framebufferNoAttachmentsSampleCounts */ + /* skip val->maxColorAttachments */ + /* skip val->sampledImageColorSampleCounts */ + /* skip val->sampledImageIntegerSampleCounts */ + /* skip val->sampledImageDepthSampleCounts */ + /* skip val->sampledImageStencilSampleCounts */ + /* skip val->storageImageSampleCounts */ + /* skip val->maxSampleMaskWords */ + /* skip val->timestampComputeAndGraphics */ + /* skip val->timestampPeriod */ + /* skip val->maxClipDistances */ + /* skip val->maxCullDistances */ + /* skip val->maxCombinedClipAndCullDistances */ + /* skip val->discreteQueuePriorities */ + /* skip val->pointSizeRange */ + /* skip val->lineWidthRange */ + /* skip val->pointSizeGranularity */ + /* skip val->lineWidthGranularity */ + /* skip val->strictLines */ + /* skip val->standardSampleLocations */ + /* skip val->optimalBufferCopyOffsetAlignment */ + /* skip val->optimalBufferCopyRowPitchAlignment */ + /* skip val->nonCoherentAtomSize */ +} + +/* struct VkPhysicalDeviceSparseProperties */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkBool32(&val->residencyStandard2DBlockShape); + size += vn_sizeof_VkBool32(&val->residencyStandard2DMultisampleBlockShape); + size += vn_sizeof_VkBool32(&val->residencyStandard3DBlockShape); + size += vn_sizeof_VkBool32(&val->residencyAlignedMipSize); + size += vn_sizeof_VkBool32(&val->residencyNonResidentStrict); + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseProperties *val) +{ + vn_decode_VkBool32(dec, &val->residencyStandard2DBlockShape); + vn_decode_VkBool32(dec, &val->residencyStandard2DMultisampleBlockShape); + vn_decode_VkBool32(dec, &val->residencyStandard3DBlockShape); + vn_decode_VkBool32(dec, &val->residencyAlignedMipSize); + vn_decode_VkBool32(dec, &val->residencyNonResidentStrict); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties *val) +{ + size_t size = 0; + /* skip val->residencyStandard2DBlockShape */ + /* skip val->residencyStandard2DMultisampleBlockShape */ + /* skip val->residencyStandard3DBlockShape */ + /* skip val->residencyAlignedMipSize */ + /* skip val->residencyNonResidentStrict */ + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseProperties *val) +{ + /* skip val->residencyStandard2DBlockShape */ + /* skip val->residencyStandard2DMultisampleBlockShape */ + /* skip val->residencyStandard3DBlockShape */ + /* skip val->residencyAlignedMipSize */ + /* skip val->residencyNonResidentStrict */ +} + +/* struct VkPhysicalDeviceProperties */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->apiVersion); + size += vn_sizeof_uint32_t(&val->driverVersion); + size += vn_sizeof_uint32_t(&val->vendorID); + size += vn_sizeof_uint32_t(&val->deviceID); + size += vn_sizeof_VkPhysicalDeviceType(&val->deviceType); + size += vn_sizeof_array_size(VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + size += vn_sizeof_blob_array(val->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + size += vn_sizeof_array_size(VK_UUID_SIZE); + size += vn_sizeof_uint8_t_array(val->pipelineCacheUUID, VK_UUID_SIZE); + size += vn_sizeof_VkPhysicalDeviceLimits(&val->limits); + size += vn_sizeof_VkPhysicalDeviceSparseProperties(&val->sparseProperties); + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties *val) +{ + vn_decode_uint32_t(dec, &val->apiVersion); + vn_decode_uint32_t(dec, &val->driverVersion); + vn_decode_uint32_t(dec, &val->vendorID); + vn_decode_uint32_t(dec, &val->deviceID); + vn_decode_VkPhysicalDeviceType(dec, &val->deviceType); + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + vn_decode_blob_array(dec, val->deviceName, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE); + vn_decode_uint8_t_array(dec, val->pipelineCacheUUID, array_size); + } + vn_decode_VkPhysicalDeviceLimits(dec, &val->limits); + vn_decode_VkPhysicalDeviceSparseProperties(dec, &val->sparseProperties); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties *val) +{ + size_t size = 0; + /* skip val->apiVersion */ + /* skip val->driverVersion */ + /* skip val->vendorID */ + /* skip val->deviceID */ + /* skip val->deviceType */ + /* skip val->deviceName */ + /* skip val->pipelineCacheUUID */ + size += vn_sizeof_VkPhysicalDeviceLimits_partial(&val->limits); + size += vn_sizeof_VkPhysicalDeviceSparseProperties_partial(&val->sparseProperties); + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties *val) +{ + /* skip val->apiVersion */ + /* skip val->driverVersion */ + /* skip val->vendorID */ + /* skip val->deviceID */ + /* skip val->deviceType */ + /* skip val->deviceName */ + /* skip val->pipelineCacheUUID */ + vn_encode_VkPhysicalDeviceLimits_partial(enc, &val->limits); + vn_encode_VkPhysicalDeviceSparseProperties_partial(enc, &val->sparseProperties); +} + +/* struct VkExtensionProperties */ + +static inline size_t +vn_sizeof_VkExtensionProperties(const VkExtensionProperties *val) +{ + size_t size = 0; + size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_blob_array(val->extensionName, VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_uint32_t(&val->specVersion); + return size; +} + +static inline void +vn_decode_VkExtensionProperties(struct vn_cs_decoder *dec, VkExtensionProperties *val) +{ + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE); + vn_decode_blob_array(dec, val->extensionName, array_size); + } + vn_decode_uint32_t(dec, &val->specVersion); +} + +static inline size_t +vn_sizeof_VkExtensionProperties_partial(const VkExtensionProperties *val) +{ + size_t size = 0; + /* skip val->extensionName */ + /* skip val->specVersion */ + return size; +} + +static inline void +vn_encode_VkExtensionProperties_partial(struct vn_cs_encoder *enc, const VkExtensionProperties *val) +{ + /* skip val->extensionName */ + /* skip val->specVersion */ +} + +/* struct VkLayerProperties */ + +static inline size_t +vn_sizeof_VkLayerProperties(const VkLayerProperties *val) +{ + size_t size = 0; + size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_blob_array(val->layerName, VK_MAX_EXTENSION_NAME_SIZE); + size += vn_sizeof_uint32_t(&val->specVersion); + size += vn_sizeof_uint32_t(&val->implementationVersion); + size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE); + size += vn_sizeof_blob_array(val->description, VK_MAX_DESCRIPTION_SIZE); + return size; +} + +static inline void +vn_decode_VkLayerProperties(struct vn_cs_decoder *dec, VkLayerProperties *val) +{ + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE); + vn_decode_blob_array(dec, val->layerName, array_size); + } + vn_decode_uint32_t(dec, &val->specVersion); + vn_decode_uint32_t(dec, &val->implementationVersion); + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE); + vn_decode_blob_array(dec, val->description, array_size); + } +} + +static inline size_t +vn_sizeof_VkLayerProperties_partial(const VkLayerProperties *val) +{ + size_t size = 0; + /* skip val->layerName */ + /* skip val->specVersion */ + /* skip val->implementationVersion */ + /* skip val->description */ + return size; +} + +static inline void +vn_encode_VkLayerProperties_partial(struct vn_cs_encoder *enc, const VkLayerProperties *val) +{ + /* skip val->layerName */ + /* skip val->specVersion */ + /* skip val->implementationVersion */ + /* skip val->description */ +} + +/* struct VkApplicationInfo chain */ + +static inline size_t +vn_sizeof_VkApplicationInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkApplicationInfo_self(const VkApplicationInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + if (val->pApplicationName) { + const size_t string_size = strlen(val->pApplicationName) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->pApplicationName, string_size); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->applicationVersion); + if (val->pEngineName) { + const size_t string_size = strlen(val->pEngineName) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->pEngineName, string_size); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->engineVersion); + size += vn_sizeof_uint32_t(&val->apiVersion); + return size; +} + +static inline size_t +vn_sizeof_VkApplicationInfo(const VkApplicationInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkApplicationInfo_pnext(val->pNext); + size += vn_sizeof_VkApplicationInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkApplicationInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkApplicationInfo_self(struct vn_cs_encoder *enc, const VkApplicationInfo *val) +{ + /* skip val->{sType,pNext} */ + if (val->pApplicationName) { + const size_t string_size = strlen(val->pApplicationName) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->pApplicationName, string_size); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->applicationVersion); + if (val->pEngineName) { + const size_t string_size = strlen(val->pEngineName) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->pEngineName, string_size); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->engineVersion); + vn_encode_uint32_t(enc, &val->apiVersion); +} + +static inline void +vn_encode_VkApplicationInfo(struct vn_cs_encoder *enc, const VkApplicationInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_APPLICATION_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_APPLICATION_INFO }); + vn_encode_VkApplicationInfo_pnext(enc, val->pNext); + vn_encode_VkApplicationInfo_self(enc, val); +} + +/* struct VkDeviceQueueCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->queueFamilyIndex); + size += vn_sizeof_uint32_t(&val->queueCount); + if (val->pQueuePriorities) { + size += vn_sizeof_array_size(val->queueCount); + size += vn_sizeof_float_array(val->pQueuePriorities, val->queueCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceQueueCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceQueueCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->queueFamilyIndex); + vn_encode_uint32_t(enc, &val->queueCount); + if (val->pQueuePriorities) { + vn_encode_array_size(enc, val->queueCount); + vn_encode_float_array(enc, val->pQueuePriorities, val->queueCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO }); + vn_encode_VkDeviceQueueCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceQueueCreateInfo_self(enc, val); +} + +/* struct VkPhysicalDeviceFeatures */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures *val) +{ + size_t size = 0; + size += vn_sizeof_VkBool32(&val->robustBufferAccess); + size += vn_sizeof_VkBool32(&val->fullDrawIndexUint32); + size += vn_sizeof_VkBool32(&val->imageCubeArray); + size += vn_sizeof_VkBool32(&val->independentBlend); + size += vn_sizeof_VkBool32(&val->geometryShader); + size += vn_sizeof_VkBool32(&val->tessellationShader); + size += vn_sizeof_VkBool32(&val->sampleRateShading); + size += vn_sizeof_VkBool32(&val->dualSrcBlend); + size += vn_sizeof_VkBool32(&val->logicOp); + size += vn_sizeof_VkBool32(&val->multiDrawIndirect); + size += vn_sizeof_VkBool32(&val->drawIndirectFirstInstance); + size += vn_sizeof_VkBool32(&val->depthClamp); + size += vn_sizeof_VkBool32(&val->depthBiasClamp); + size += vn_sizeof_VkBool32(&val->fillModeNonSolid); + size += vn_sizeof_VkBool32(&val->depthBounds); + size += vn_sizeof_VkBool32(&val->wideLines); + size += vn_sizeof_VkBool32(&val->largePoints); + size += vn_sizeof_VkBool32(&val->alphaToOne); + size += vn_sizeof_VkBool32(&val->multiViewport); + size += vn_sizeof_VkBool32(&val->samplerAnisotropy); + size += vn_sizeof_VkBool32(&val->textureCompressionETC2); + size += vn_sizeof_VkBool32(&val->textureCompressionASTC_LDR); + size += vn_sizeof_VkBool32(&val->textureCompressionBC); + size += vn_sizeof_VkBool32(&val->occlusionQueryPrecise); + size += vn_sizeof_VkBool32(&val->pipelineStatisticsQuery); + size += vn_sizeof_VkBool32(&val->vertexPipelineStoresAndAtomics); + size += vn_sizeof_VkBool32(&val->fragmentStoresAndAtomics); + size += vn_sizeof_VkBool32(&val->shaderTessellationAndGeometryPointSize); + size += vn_sizeof_VkBool32(&val->shaderImageGatherExtended); + size += vn_sizeof_VkBool32(&val->shaderStorageImageExtendedFormats); + size += vn_sizeof_VkBool32(&val->shaderStorageImageMultisample); + size += vn_sizeof_VkBool32(&val->shaderStorageImageReadWithoutFormat); + size += vn_sizeof_VkBool32(&val->shaderStorageImageWriteWithoutFormat); + size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderClipDistance); + size += vn_sizeof_VkBool32(&val->shaderCullDistance); + size += vn_sizeof_VkBool32(&val->shaderFloat64); + size += vn_sizeof_VkBool32(&val->shaderInt64); + size += vn_sizeof_VkBool32(&val->shaderInt16); + size += vn_sizeof_VkBool32(&val->shaderResourceResidency); + size += vn_sizeof_VkBool32(&val->shaderResourceMinLod); + size += vn_sizeof_VkBool32(&val->sparseBinding); + size += vn_sizeof_VkBool32(&val->sparseResidencyBuffer); + size += vn_sizeof_VkBool32(&val->sparseResidencyImage2D); + size += vn_sizeof_VkBool32(&val->sparseResidencyImage3D); + size += vn_sizeof_VkBool32(&val->sparseResidency2Samples); + size += vn_sizeof_VkBool32(&val->sparseResidency4Samples); + size += vn_sizeof_VkBool32(&val->sparseResidency8Samples); + size += vn_sizeof_VkBool32(&val->sparseResidency16Samples); + size += vn_sizeof_VkBool32(&val->sparseResidencyAliased); + size += vn_sizeof_VkBool32(&val->variableMultisampleRate); + size += vn_sizeof_VkBool32(&val->inheritedQueries); + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val) +{ + vn_encode_VkBool32(enc, &val->robustBufferAccess); + vn_encode_VkBool32(enc, &val->fullDrawIndexUint32); + vn_encode_VkBool32(enc, &val->imageCubeArray); + vn_encode_VkBool32(enc, &val->independentBlend); + vn_encode_VkBool32(enc, &val->geometryShader); + vn_encode_VkBool32(enc, &val->tessellationShader); + vn_encode_VkBool32(enc, &val->sampleRateShading); + vn_encode_VkBool32(enc, &val->dualSrcBlend); + vn_encode_VkBool32(enc, &val->logicOp); + vn_encode_VkBool32(enc, &val->multiDrawIndirect); + vn_encode_VkBool32(enc, &val->drawIndirectFirstInstance); + vn_encode_VkBool32(enc, &val->depthClamp); + vn_encode_VkBool32(enc, &val->depthBiasClamp); + vn_encode_VkBool32(enc, &val->fillModeNonSolid); + vn_encode_VkBool32(enc, &val->depthBounds); + vn_encode_VkBool32(enc, &val->wideLines); + vn_encode_VkBool32(enc, &val->largePoints); + vn_encode_VkBool32(enc, &val->alphaToOne); + vn_encode_VkBool32(enc, &val->multiViewport); + vn_encode_VkBool32(enc, &val->samplerAnisotropy); + vn_encode_VkBool32(enc, &val->textureCompressionETC2); + vn_encode_VkBool32(enc, &val->textureCompressionASTC_LDR); + vn_encode_VkBool32(enc, &val->textureCompressionBC); + vn_encode_VkBool32(enc, &val->occlusionQueryPrecise); + vn_encode_VkBool32(enc, &val->pipelineStatisticsQuery); + vn_encode_VkBool32(enc, &val->vertexPipelineStoresAndAtomics); + vn_encode_VkBool32(enc, &val->fragmentStoresAndAtomics); + vn_encode_VkBool32(enc, &val->shaderTessellationAndGeometryPointSize); + vn_encode_VkBool32(enc, &val->shaderImageGatherExtended); + vn_encode_VkBool32(enc, &val->shaderStorageImageExtendedFormats); + vn_encode_VkBool32(enc, &val->shaderStorageImageMultisample); + vn_encode_VkBool32(enc, &val->shaderStorageImageReadWithoutFormat); + vn_encode_VkBool32(enc, &val->shaderStorageImageWriteWithoutFormat); + vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderSampledImageArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageImageArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderClipDistance); + vn_encode_VkBool32(enc, &val->shaderCullDistance); + vn_encode_VkBool32(enc, &val->shaderFloat64); + vn_encode_VkBool32(enc, &val->shaderInt64); + vn_encode_VkBool32(enc, &val->shaderInt16); + vn_encode_VkBool32(enc, &val->shaderResourceResidency); + vn_encode_VkBool32(enc, &val->shaderResourceMinLod); + vn_encode_VkBool32(enc, &val->sparseBinding); + vn_encode_VkBool32(enc, &val->sparseResidencyBuffer); + vn_encode_VkBool32(enc, &val->sparseResidencyImage2D); + vn_encode_VkBool32(enc, &val->sparseResidencyImage3D); + vn_encode_VkBool32(enc, &val->sparseResidency2Samples); + vn_encode_VkBool32(enc, &val->sparseResidency4Samples); + vn_encode_VkBool32(enc, &val->sparseResidency8Samples); + vn_encode_VkBool32(enc, &val->sparseResidency16Samples); + vn_encode_VkBool32(enc, &val->sparseResidencyAliased); + vn_encode_VkBool32(enc, &val->variableMultisampleRate); + vn_encode_VkBool32(enc, &val->inheritedQueries); +} + +static inline void +vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val) +{ + vn_decode_VkBool32(dec, &val->robustBufferAccess); + vn_decode_VkBool32(dec, &val->fullDrawIndexUint32); + vn_decode_VkBool32(dec, &val->imageCubeArray); + vn_decode_VkBool32(dec, &val->independentBlend); + vn_decode_VkBool32(dec, &val->geometryShader); + vn_decode_VkBool32(dec, &val->tessellationShader); + vn_decode_VkBool32(dec, &val->sampleRateShading); + vn_decode_VkBool32(dec, &val->dualSrcBlend); + vn_decode_VkBool32(dec, &val->logicOp); + vn_decode_VkBool32(dec, &val->multiDrawIndirect); + vn_decode_VkBool32(dec, &val->drawIndirectFirstInstance); + vn_decode_VkBool32(dec, &val->depthClamp); + vn_decode_VkBool32(dec, &val->depthBiasClamp); + vn_decode_VkBool32(dec, &val->fillModeNonSolid); + vn_decode_VkBool32(dec, &val->depthBounds); + vn_decode_VkBool32(dec, &val->wideLines); + vn_decode_VkBool32(dec, &val->largePoints); + vn_decode_VkBool32(dec, &val->alphaToOne); + vn_decode_VkBool32(dec, &val->multiViewport); + vn_decode_VkBool32(dec, &val->samplerAnisotropy); + vn_decode_VkBool32(dec, &val->textureCompressionETC2); + vn_decode_VkBool32(dec, &val->textureCompressionASTC_LDR); + vn_decode_VkBool32(dec, &val->textureCompressionBC); + vn_decode_VkBool32(dec, &val->occlusionQueryPrecise); + vn_decode_VkBool32(dec, &val->pipelineStatisticsQuery); + vn_decode_VkBool32(dec, &val->vertexPipelineStoresAndAtomics); + vn_decode_VkBool32(dec, &val->fragmentStoresAndAtomics); + vn_decode_VkBool32(dec, &val->shaderTessellationAndGeometryPointSize); + vn_decode_VkBool32(dec, &val->shaderImageGatherExtended); + vn_decode_VkBool32(dec, &val->shaderStorageImageExtendedFormats); + vn_decode_VkBool32(dec, &val->shaderStorageImageMultisample); + vn_decode_VkBool32(dec, &val->shaderStorageImageReadWithoutFormat); + vn_decode_VkBool32(dec, &val->shaderStorageImageWriteWithoutFormat); + vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderSampledImageArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageImageArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderClipDistance); + vn_decode_VkBool32(dec, &val->shaderCullDistance); + vn_decode_VkBool32(dec, &val->shaderFloat64); + vn_decode_VkBool32(dec, &val->shaderInt64); + vn_decode_VkBool32(dec, &val->shaderInt16); + vn_decode_VkBool32(dec, &val->shaderResourceResidency); + vn_decode_VkBool32(dec, &val->shaderResourceMinLod); + vn_decode_VkBool32(dec, &val->sparseBinding); + vn_decode_VkBool32(dec, &val->sparseResidencyBuffer); + vn_decode_VkBool32(dec, &val->sparseResidencyImage2D); + vn_decode_VkBool32(dec, &val->sparseResidencyImage3D); + vn_decode_VkBool32(dec, &val->sparseResidency2Samples); + vn_decode_VkBool32(dec, &val->sparseResidency4Samples); + vn_decode_VkBool32(dec, &val->sparseResidency8Samples); + vn_decode_VkBool32(dec, &val->sparseResidency16Samples); + vn_decode_VkBool32(dec, &val->sparseResidencyAliased); + vn_decode_VkBool32(dec, &val->variableMultisampleRate); + vn_decode_VkBool32(dec, &val->inheritedQueries); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures *val) +{ + size_t size = 0; + /* skip val->robustBufferAccess */ + /* skip val->fullDrawIndexUint32 */ + /* skip val->imageCubeArray */ + /* skip val->independentBlend */ + /* skip val->geometryShader */ + /* skip val->tessellationShader */ + /* skip val->sampleRateShading */ + /* skip val->dualSrcBlend */ + /* skip val->logicOp */ + /* skip val->multiDrawIndirect */ + /* skip val->drawIndirectFirstInstance */ + /* skip val->depthClamp */ + /* skip val->depthBiasClamp */ + /* skip val->fillModeNonSolid */ + /* skip val->depthBounds */ + /* skip val->wideLines */ + /* skip val->largePoints */ + /* skip val->alphaToOne */ + /* skip val->multiViewport */ + /* skip val->samplerAnisotropy */ + /* skip val->textureCompressionETC2 */ + /* skip val->textureCompressionASTC_LDR */ + /* skip val->textureCompressionBC */ + /* skip val->occlusionQueryPrecise */ + /* skip val->pipelineStatisticsQuery */ + /* skip val->vertexPipelineStoresAndAtomics */ + /* skip val->fragmentStoresAndAtomics */ + /* skip val->shaderTessellationAndGeometryPointSize */ + /* skip val->shaderImageGatherExtended */ + /* skip val->shaderStorageImageExtendedFormats */ + /* skip val->shaderStorageImageMultisample */ + /* skip val->shaderStorageImageReadWithoutFormat */ + /* skip val->shaderStorageImageWriteWithoutFormat */ + /* skip val->shaderUniformBufferArrayDynamicIndexing */ + /* skip val->shaderSampledImageArrayDynamicIndexing */ + /* skip val->shaderStorageBufferArrayDynamicIndexing */ + /* skip val->shaderStorageImageArrayDynamicIndexing */ + /* skip val->shaderClipDistance */ + /* skip val->shaderCullDistance */ + /* skip val->shaderFloat64 */ + /* skip val->shaderInt64 */ + /* skip val->shaderInt16 */ + /* skip val->shaderResourceResidency */ + /* skip val->shaderResourceMinLod */ + /* skip val->sparseBinding */ + /* skip val->sparseResidencyBuffer */ + /* skip val->sparseResidencyImage2D */ + /* skip val->sparseResidencyImage3D */ + /* skip val->sparseResidency2Samples */ + /* skip val->sparseResidency4Samples */ + /* skip val->sparseResidency8Samples */ + /* skip val->sparseResidency16Samples */ + /* skip val->sparseResidencyAliased */ + /* skip val->variableMultisampleRate */ + /* skip val->inheritedQueries */ + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val) +{ + /* skip val->robustBufferAccess */ + /* skip val->fullDrawIndexUint32 */ + /* skip val->imageCubeArray */ + /* skip val->independentBlend */ + /* skip val->geometryShader */ + /* skip val->tessellationShader */ + /* skip val->sampleRateShading */ + /* skip val->dualSrcBlend */ + /* skip val->logicOp */ + /* skip val->multiDrawIndirect */ + /* skip val->drawIndirectFirstInstance */ + /* skip val->depthClamp */ + /* skip val->depthBiasClamp */ + /* skip val->fillModeNonSolid */ + /* skip val->depthBounds */ + /* skip val->wideLines */ + /* skip val->largePoints */ + /* skip val->alphaToOne */ + /* skip val->multiViewport */ + /* skip val->samplerAnisotropy */ + /* skip val->textureCompressionETC2 */ + /* skip val->textureCompressionASTC_LDR */ + /* skip val->textureCompressionBC */ + /* skip val->occlusionQueryPrecise */ + /* skip val->pipelineStatisticsQuery */ + /* skip val->vertexPipelineStoresAndAtomics */ + /* skip val->fragmentStoresAndAtomics */ + /* skip val->shaderTessellationAndGeometryPointSize */ + /* skip val->shaderImageGatherExtended */ + /* skip val->shaderStorageImageExtendedFormats */ + /* skip val->shaderStorageImageMultisample */ + /* skip val->shaderStorageImageReadWithoutFormat */ + /* skip val->shaderStorageImageWriteWithoutFormat */ + /* skip val->shaderUniformBufferArrayDynamicIndexing */ + /* skip val->shaderSampledImageArrayDynamicIndexing */ + /* skip val->shaderStorageBufferArrayDynamicIndexing */ + /* skip val->shaderStorageImageArrayDynamicIndexing */ + /* skip val->shaderClipDistance */ + /* skip val->shaderCullDistance */ + /* skip val->shaderFloat64 */ + /* skip val->shaderInt64 */ + /* skip val->shaderInt16 */ + /* skip val->shaderResourceResidency */ + /* skip val->shaderResourceMinLod */ + /* skip val->sparseBinding */ + /* skip val->sparseResidencyBuffer */ + /* skip val->sparseResidencyImage2D */ + /* skip val->sparseResidencyImage3D */ + /* skip val->sparseResidency2Samples */ + /* skip val->sparseResidency4Samples */ + /* skip val->sparseResidency8Samples */ + /* skip val->sparseResidency16Samples */ + /* skip val->sparseResidencyAliased */ + /* skip val->variableMultisampleRate */ + /* skip val->inheritedQueries */ +} + +/* struct VkPhysicalDeviceVariablePointersFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer); + size += vn_sizeof_VkBool32(&val->variablePointers); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer); + vn_encode_VkBool32(enc, &val->variablePointers); +} + +static inline void +vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES }); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer); + vn_decode_VkBool32(dec, &val->variablePointers); +} + +static inline void +vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->variablePointersStorageBuffer */ + /* skip val->variablePointers */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->variablePointersStorageBuffer */ + /* skip val->variablePointers */ +} + +static inline void +vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES }); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceMultiviewFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->multiview); + size += vn_sizeof_VkBool32(&val->multiviewGeometryShader); + size += vn_sizeof_VkBool32(&val->multiviewTessellationShader); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->multiview); + vn_encode_VkBool32(enc, &val->multiviewGeometryShader); + vn_encode_VkBool32(enc, &val->multiviewTessellationShader); +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES }); + vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->multiview); + vn_decode_VkBool32(dec, &val->multiviewGeometryShader); + vn_decode_VkBool32(dec, &val->multiviewTessellationShader); +} + +static inline void +vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->multiview */ + /* skip val->multiviewGeometryShader */ + /* skip val->multiviewTessellationShader */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->multiview */ + /* skip val->multiviewGeometryShader */ + /* skip val->multiviewTessellationShader */ +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES }); + vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDevice16BitStorageFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess); + size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess); + size += vn_sizeof_VkBool32(&val->storagePushConstant16); + size += vn_sizeof_VkBool32(&val->storageInputOutput16); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess); + vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess); + vn_encode_VkBool32(enc, &val->storagePushConstant16); + vn_encode_VkBool32(enc, &val->storageInputOutput16); +} + +static inline void +vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES }); + vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess); + vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess); + vn_decode_VkBool32(dec, &val->storagePushConstant16); + vn_decode_VkBool32(dec, &val->storageInputOutput16); +} + +static inline void +vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->storageBuffer16BitAccess */ + /* skip val->uniformAndStorageBuffer16BitAccess */ + /* skip val->storagePushConstant16 */ + /* skip val->storageInputOutput16 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->storageBuffer16BitAccess */ + /* skip val->uniformAndStorageBuffer16BitAccess */ + /* skip val->storagePushConstant16 */ + /* skip val->storageInputOutput16 */ +} + +static inline void +vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES }); + vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES }); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderSubgroupExtendedTypes */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderSubgroupExtendedTypes */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES }); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->samplerYcbcrConversion); +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES }); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->samplerYcbcrConversion); +} + +static inline void +vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->samplerYcbcrConversion */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->samplerYcbcrConversion */ +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES }); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceProtectedMemoryFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->protectedMemory); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->protectedMemory); +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES }); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->protectedMemory); +} + +static inline void +vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->protectedMemory */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->protectedMemory */ +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES }); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderDrawParameters); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderDrawParameters); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES }); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderDrawParameters); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderDrawParameters */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderDrawParameters */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES }); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderFloat16Int8Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderFloat16); + size += vn_sizeof_VkBool32(&val->shaderInt8); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderFloat16); + vn_encode_VkBool32(enc, &val->shaderInt8); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES }); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderFloat16); + vn_decode_VkBool32(dec, &val->shaderInt8); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderFloat16 */ + /* skip val->shaderInt8 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderFloat16 */ + /* skip val->shaderInt8 */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES }); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceHostQueryResetFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->hostQueryReset); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->hostQueryReset); +} + +static inline void +vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES }); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->hostQueryReset); +} + +static inline void +vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->hostQueryReset */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->hostQueryReset */ +} + +static inline void +vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES }); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending); + size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound); + size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount); + size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending); + vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound); + vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount); + vn_encode_VkBool32(enc, &val->runtimeDescriptorArray); +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES }); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending); + vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound); + vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount); + vn_decode_VkBool32(dec, &val->runtimeDescriptorArray); +} + +static inline void +vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderInputAttachmentArrayDynamicIndexing */ + /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */ + /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */ + /* skip val->shaderUniformBufferArrayNonUniformIndexing */ + /* skip val->shaderSampledImageArrayNonUniformIndexing */ + /* skip val->shaderStorageBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageImageArrayNonUniformIndexing */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexing */ + /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */ + /* skip val->descriptorBindingUniformBufferUpdateAfterBind */ + /* skip val->descriptorBindingSampledImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageBufferUpdateAfterBind */ + /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingUpdateUnusedWhilePending */ + /* skip val->descriptorBindingPartiallyBound */ + /* skip val->descriptorBindingVariableDescriptorCount */ + /* skip val->runtimeDescriptorArray */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderInputAttachmentArrayDynamicIndexing */ + /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */ + /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */ + /* skip val->shaderUniformBufferArrayNonUniformIndexing */ + /* skip val->shaderSampledImageArrayNonUniformIndexing */ + /* skip val->shaderStorageBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageImageArrayNonUniformIndexing */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexing */ + /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */ + /* skip val->descriptorBindingUniformBufferUpdateAfterBind */ + /* skip val->descriptorBindingSampledImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageBufferUpdateAfterBind */ + /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingUpdateUnusedWhilePending */ + /* skip val->descriptorBindingPartiallyBound */ + /* skip val->descriptorBindingVariableDescriptorCount */ + /* skip val->runtimeDescriptorArray */ +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES }); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->timelineSemaphore); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->timelineSemaphore); +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES }); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->timelineSemaphore); +} + +static inline void +vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->timelineSemaphore */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->timelineSemaphore */ +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES }); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDevice8BitStorageFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess); + size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess); + size += vn_sizeof_VkBool32(&val->storagePushConstant8); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess); + vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess); + vn_encode_VkBool32(enc, &val->storagePushConstant8); +} + +static inline void +vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES }); + vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess); + vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess); + vn_decode_VkBool32(dec, &val->storagePushConstant8); +} + +static inline void +vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->storageBuffer8BitAccess */ + /* skip val->uniformAndStorageBuffer8BitAccess */ + /* skip val->storagePushConstant8 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->storageBuffer8BitAccess */ + /* skip val->uniformAndStorageBuffer8BitAccess */ + /* skip val->storagePushConstant8 */ +} + +static inline void +vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES }); + vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->vulkanMemoryModel); + size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope); + size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->vulkanMemoryModel); + vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope); + vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES }); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->vulkanMemoryModel); + vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope); + vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->vulkanMemoryModel */ + /* skip val->vulkanMemoryModelDeviceScope */ + /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->vulkanMemoryModel */ + /* skip val->vulkanMemoryModelDeviceScope */ + /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES }); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceShaderAtomicInt64Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics); + size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics); + vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES }); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics); + vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics); +} + +static inline void +vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->shaderBufferInt64Atomics */ + /* skip val->shaderSharedInt64Atomics */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->shaderBufferInt64Atomics */ + /* skip val->shaderSharedInt64Atomics */ +} + +static inline void +vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES }); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->transformFeedback); + size += vn_sizeof_VkBool32(&val->geometryStreams); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->transformFeedback); + vn_encode_VkBool32(enc, &val->geometryStreams); +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->transformFeedback); + vn_decode_VkBool32(dec, &val->geometryStreams); +} + +static inline void +vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->transformFeedback */ + /* skip val->geometryStreams */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->transformFeedback */ + /* skip val->geometryStreams */ +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT }); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->scalarBlockLayout); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->scalarBlockLayout); +} + +static inline void +vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES }); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->scalarBlockLayout); +} + +static inline void +vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->scalarBlockLayout */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->scalarBlockLayout */ +} + +static inline void +vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES }); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout); +} + +static inline void +vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES }); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout); +} + +static inline void +vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->uniformBufferStandardLayout */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->uniformBufferStandardLayout */ +} + +static inline void +vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES }); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->bufferDeviceAddress); + size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay); + size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->bufferDeviceAddress); + vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay); + vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice); +} + +static inline void +vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES }); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->bufferDeviceAddress); + vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay); + vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice); +} + +static inline void +vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->bufferDeviceAddress */ + /* skip val->bufferDeviceAddressCaptureReplay */ + /* skip val->bufferDeviceAddressMultiDevice */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->bufferDeviceAddress */ + /* skip val->bufferDeviceAddressCaptureReplay */ + /* skip val->bufferDeviceAddressMultiDevice */ +} + +static inline void +vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES }); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->imagelessFramebuffer); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->imagelessFramebuffer); +} + +static inline void +vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES }); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->imagelessFramebuffer); +} + +static inline void +vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->imagelessFramebuffer */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->imagelessFramebuffer */ +} + +static inline void +vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES }); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts); +} + +static inline void +vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES }); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts); +} + +static inline void +vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->separateDepthStencilLayouts */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->separateDepthStencilLayouts */ +} + +static inline void +vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES }); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceVulkan11Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess); + size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess); + size += vn_sizeof_VkBool32(&val->storagePushConstant16); + size += vn_sizeof_VkBool32(&val->storageInputOutput16); + size += vn_sizeof_VkBool32(&val->multiview); + size += vn_sizeof_VkBool32(&val->multiviewGeometryShader); + size += vn_sizeof_VkBool32(&val->multiviewTessellationShader); + size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer); + size += vn_sizeof_VkBool32(&val->variablePointers); + size += vn_sizeof_VkBool32(&val->protectedMemory); + size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion); + size += vn_sizeof_VkBool32(&val->shaderDrawParameters); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess); + vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess); + vn_encode_VkBool32(enc, &val->storagePushConstant16); + vn_encode_VkBool32(enc, &val->storageInputOutput16); + vn_encode_VkBool32(enc, &val->multiview); + vn_encode_VkBool32(enc, &val->multiviewGeometryShader); + vn_encode_VkBool32(enc, &val->multiviewTessellationShader); + vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer); + vn_encode_VkBool32(enc, &val->variablePointers); + vn_encode_VkBool32(enc, &val->protectedMemory); + vn_encode_VkBool32(enc, &val->samplerYcbcrConversion); + vn_encode_VkBool32(enc, &val->shaderDrawParameters); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES }); + vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess); + vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess); + vn_decode_VkBool32(dec, &val->storagePushConstant16); + vn_decode_VkBool32(dec, &val->storageInputOutput16); + vn_decode_VkBool32(dec, &val->multiview); + vn_decode_VkBool32(dec, &val->multiviewGeometryShader); + vn_decode_VkBool32(dec, &val->multiviewTessellationShader); + vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer); + vn_decode_VkBool32(dec, &val->variablePointers); + vn_decode_VkBool32(dec, &val->protectedMemory); + vn_decode_VkBool32(dec, &val->samplerYcbcrConversion); + vn_decode_VkBool32(dec, &val->shaderDrawParameters); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->storageBuffer16BitAccess */ + /* skip val->uniformAndStorageBuffer16BitAccess */ + /* skip val->storagePushConstant16 */ + /* skip val->storageInputOutput16 */ + /* skip val->multiview */ + /* skip val->multiviewGeometryShader */ + /* skip val->multiviewTessellationShader */ + /* skip val->variablePointersStorageBuffer */ + /* skip val->variablePointers */ + /* skip val->protectedMemory */ + /* skip val->samplerYcbcrConversion */ + /* skip val->shaderDrawParameters */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->storageBuffer16BitAccess */ + /* skip val->uniformAndStorageBuffer16BitAccess */ + /* skip val->storagePushConstant16 */ + /* skip val->storageInputOutput16 */ + /* skip val->multiview */ + /* skip val->multiviewGeometryShader */ + /* skip val->multiviewTessellationShader */ + /* skip val->variablePointersStorageBuffer */ + /* skip val->variablePointers */ + /* skip val->protectedMemory */ + /* skip val->samplerYcbcrConversion */ + /* skip val->shaderDrawParameters */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES }); + vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceVulkan12Features chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge); + size += vn_sizeof_VkBool32(&val->drawIndirectCount); + size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess); + size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess); + size += vn_sizeof_VkBool32(&val->storagePushConstant8); + size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics); + size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics); + size += vn_sizeof_VkBool32(&val->shaderFloat16); + size += vn_sizeof_VkBool32(&val->shaderInt8); + size += vn_sizeof_VkBool32(&val->descriptorIndexing); + size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing); + size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing); + size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending); + size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound); + size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount); + size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray); + size += vn_sizeof_VkBool32(&val->samplerFilterMinmax); + size += vn_sizeof_VkBool32(&val->scalarBlockLayout); + size += vn_sizeof_VkBool32(&val->imagelessFramebuffer); + size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout); + size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes); + size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts); + size += vn_sizeof_VkBool32(&val->hostQueryReset); + size += vn_sizeof_VkBool32(&val->timelineSemaphore); + size += vn_sizeof_VkBool32(&val->bufferDeviceAddress); + size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay); + size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice); + size += vn_sizeof_VkBool32(&val->vulkanMemoryModel); + size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope); + size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains); + size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex); + size += vn_sizeof_VkBool32(&val->shaderOutputLayer); + size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge); + vn_encode_VkBool32(enc, &val->drawIndirectCount); + vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess); + vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess); + vn_encode_VkBool32(enc, &val->storagePushConstant8); + vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics); + vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics); + vn_encode_VkBool32(enc, &val->shaderFloat16); + vn_encode_VkBool32(enc, &val->shaderInt8); + vn_encode_VkBool32(enc, &val->descriptorIndexing); + vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing); + vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing); + vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind); + vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending); + vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound); + vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount); + vn_encode_VkBool32(enc, &val->runtimeDescriptorArray); + vn_encode_VkBool32(enc, &val->samplerFilterMinmax); + vn_encode_VkBool32(enc, &val->scalarBlockLayout); + vn_encode_VkBool32(enc, &val->imagelessFramebuffer); + vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout); + vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes); + vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts); + vn_encode_VkBool32(enc, &val->hostQueryReset); + vn_encode_VkBool32(enc, &val->timelineSemaphore); + vn_encode_VkBool32(enc, &val->bufferDeviceAddress); + vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay); + vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice); + vn_encode_VkBool32(enc, &val->vulkanMemoryModel); + vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope); + vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains); + vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex); + vn_encode_VkBool32(enc, &val->shaderOutputLayer); + vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES }); + vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge); + vn_decode_VkBool32(dec, &val->drawIndirectCount); + vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess); + vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess); + vn_decode_VkBool32(dec, &val->storagePushConstant8); + vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics); + vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics); + vn_decode_VkBool32(dec, &val->shaderFloat16); + vn_decode_VkBool32(dec, &val->shaderInt8); + vn_decode_VkBool32(dec, &val->descriptorIndexing); + vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing); + vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing); + vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind); + vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending); + vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound); + vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount); + vn_decode_VkBool32(dec, &val->runtimeDescriptorArray); + vn_decode_VkBool32(dec, &val->samplerFilterMinmax); + vn_decode_VkBool32(dec, &val->scalarBlockLayout); + vn_decode_VkBool32(dec, &val->imagelessFramebuffer); + vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout); + vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes); + vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts); + vn_decode_VkBool32(dec, &val->hostQueryReset); + vn_decode_VkBool32(dec, &val->timelineSemaphore); + vn_decode_VkBool32(dec, &val->bufferDeviceAddress); + vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay); + vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice); + vn_decode_VkBool32(dec, &val->vulkanMemoryModel); + vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope); + vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains); + vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex); + vn_decode_VkBool32(dec, &val->shaderOutputLayer); + vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->samplerMirrorClampToEdge */ + /* skip val->drawIndirectCount */ + /* skip val->storageBuffer8BitAccess */ + /* skip val->uniformAndStorageBuffer8BitAccess */ + /* skip val->storagePushConstant8 */ + /* skip val->shaderBufferInt64Atomics */ + /* skip val->shaderSharedInt64Atomics */ + /* skip val->shaderFloat16 */ + /* skip val->shaderInt8 */ + /* skip val->descriptorIndexing */ + /* skip val->shaderInputAttachmentArrayDynamicIndexing */ + /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */ + /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */ + /* skip val->shaderUniformBufferArrayNonUniformIndexing */ + /* skip val->shaderSampledImageArrayNonUniformIndexing */ + /* skip val->shaderStorageBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageImageArrayNonUniformIndexing */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexing */ + /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */ + /* skip val->descriptorBindingUniformBufferUpdateAfterBind */ + /* skip val->descriptorBindingSampledImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageBufferUpdateAfterBind */ + /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingUpdateUnusedWhilePending */ + /* skip val->descriptorBindingPartiallyBound */ + /* skip val->descriptorBindingVariableDescriptorCount */ + /* skip val->runtimeDescriptorArray */ + /* skip val->samplerFilterMinmax */ + /* skip val->scalarBlockLayout */ + /* skip val->imagelessFramebuffer */ + /* skip val->uniformBufferStandardLayout */ + /* skip val->shaderSubgroupExtendedTypes */ + /* skip val->separateDepthStencilLayouts */ + /* skip val->hostQueryReset */ + /* skip val->timelineSemaphore */ + /* skip val->bufferDeviceAddress */ + /* skip val->bufferDeviceAddressCaptureReplay */ + /* skip val->bufferDeviceAddressMultiDevice */ + /* skip val->vulkanMemoryModel */ + /* skip val->vulkanMemoryModelDeviceScope */ + /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */ + /* skip val->shaderOutputViewportIndex */ + /* skip val->shaderOutputLayer */ + /* skip val->subgroupBroadcastDynamicId */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->samplerMirrorClampToEdge */ + /* skip val->drawIndirectCount */ + /* skip val->storageBuffer8BitAccess */ + /* skip val->uniformAndStorageBuffer8BitAccess */ + /* skip val->storagePushConstant8 */ + /* skip val->shaderBufferInt64Atomics */ + /* skip val->shaderSharedInt64Atomics */ + /* skip val->shaderFloat16 */ + /* skip val->shaderInt8 */ + /* skip val->descriptorIndexing */ + /* skip val->shaderInputAttachmentArrayDynamicIndexing */ + /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */ + /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */ + /* skip val->shaderUniformBufferArrayNonUniformIndexing */ + /* skip val->shaderSampledImageArrayNonUniformIndexing */ + /* skip val->shaderStorageBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageImageArrayNonUniformIndexing */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexing */ + /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */ + /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */ + /* skip val->descriptorBindingUniformBufferUpdateAfterBind */ + /* skip val->descriptorBindingSampledImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageImageUpdateAfterBind */ + /* skip val->descriptorBindingStorageBufferUpdateAfterBind */ + /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */ + /* skip val->descriptorBindingUpdateUnusedWhilePending */ + /* skip val->descriptorBindingPartiallyBound */ + /* skip val->descriptorBindingVariableDescriptorCount */ + /* skip val->runtimeDescriptorArray */ + /* skip val->samplerFilterMinmax */ + /* skip val->scalarBlockLayout */ + /* skip val->imagelessFramebuffer */ + /* skip val->uniformBufferStandardLayout */ + /* skip val->shaderSubgroupExtendedTypes */ + /* skip val->separateDepthStencilLayouts */ + /* skip val->hostQueryReset */ + /* skip val->timelineSemaphore */ + /* skip val->bufferDeviceAddress */ + /* skip val->bufferDeviceAddressCaptureReplay */ + /* skip val->bufferDeviceAddressMultiDevice */ + /* skip val->vulkanMemoryModel */ + /* skip val->vulkanMemoryModelDeviceScope */ + /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */ + /* skip val->shaderOutputViewportIndex */ + /* skip val->shaderOutputLayer */ + /* skip val->subgroupBroadcastDynamicId */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES }); + vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceFeatures2 chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkPhysicalDeviceFeatures(enc, &val->features); +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 }); + vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceFeatures2_self(enc, val); +} + +static inline void +vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkPhysicalDeviceFeatures(dec, &val->features); +} + +static inline void +vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceFeatures2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features); +} + +static inline void +vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 }); + vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val); +} + +/* struct VkDeviceGroupDeviceCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->physicalDeviceCount); + if (val->pPhysicalDevices) { + size += vn_sizeof_array_size(val->physicalDeviceCount); + for (uint32_t i = 0; i < val->physicalDeviceCount; i++) + size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->physicalDeviceCount); + if (val->pPhysicalDevices) { + vn_encode_array_size(enc, val->physicalDeviceCount); + for (uint32_t i = 0; i < val->physicalDeviceCount; i++) + vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO }); + vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val); +} + +/* struct VkDeviceCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->queueCreateInfoCount); + if (val->pQueueCreateInfos) { + size += vn_sizeof_array_size(val->queueCreateInfoCount); + for (uint32_t i = 0; i < val->queueCreateInfoCount; i++) + size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->enabledLayerCount); + if (val->ppEnabledLayerNames) { + size += vn_sizeof_array_size(val->enabledLayerCount); + for (uint32_t i = 0; i < val->enabledLayerCount; i++) { + const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size); + } + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->enabledExtensionCount); + if (val->ppEnabledExtensionNames) { + size += vn_sizeof_array_size(val->enabledExtensionCount); + for (uint32_t i = 0; i < val->enabledExtensionCount; i++) { + const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size); + } + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_simple_pointer(val->pEnabledFeatures); + if (val->pEnabledFeatures) + size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->queueCreateInfoCount); + if (val->pQueueCreateInfos) { + vn_encode_array_size(enc, val->queueCreateInfoCount); + for (uint32_t i = 0; i < val->queueCreateInfoCount; i++) + vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->enabledLayerCount); + if (val->ppEnabledLayerNames) { + vn_encode_array_size(enc, val->enabledLayerCount); + for (uint32_t i = 0; i < val->enabledLayerCount; i++) { + const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size); + } + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->enabledExtensionCount); + if (val->ppEnabledExtensionNames) { + vn_encode_array_size(enc, val->enabledExtensionCount); + for (uint32_t i = 0; i < val->enabledExtensionCount; i++) { + const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size); + } + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, val->pEnabledFeatures)) + vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures); +} + +static inline void +vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }); + vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceCreateInfo_self(enc, val); +} + +/* struct VkInstanceCreateInfo chain */ + +static inline size_t +vn_sizeof_VkInstanceCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkInstanceCreateInfo_self(const VkInstanceCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_simple_pointer(val->pApplicationInfo); + if (val->pApplicationInfo) + size += vn_sizeof_VkApplicationInfo(val->pApplicationInfo); + size += vn_sizeof_uint32_t(&val->enabledLayerCount); + if (val->ppEnabledLayerNames) { + size += vn_sizeof_array_size(val->enabledLayerCount); + for (uint32_t i = 0; i < val->enabledLayerCount; i++) { + const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size); + } + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->enabledExtensionCount); + if (val->ppEnabledExtensionNames) { + size += vn_sizeof_array_size(val->enabledExtensionCount); + for (uint32_t i = 0; i < val->enabledExtensionCount; i++) { + const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size); + } + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkInstanceCreateInfo(const VkInstanceCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkInstanceCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkInstanceCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkInstanceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkInstanceCreateInfo_self(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + if (vn_encode_simple_pointer(enc, val->pApplicationInfo)) + vn_encode_VkApplicationInfo(enc, val->pApplicationInfo); + vn_encode_uint32_t(enc, &val->enabledLayerCount); + if (val->ppEnabledLayerNames) { + vn_encode_array_size(enc, val->enabledLayerCount); + for (uint32_t i = 0; i < val->enabledLayerCount; i++) { + const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size); + } + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->enabledExtensionCount); + if (val->ppEnabledExtensionNames) { + vn_encode_array_size(enc, val->enabledExtensionCount); + for (uint32_t i = 0; i < val->enabledExtensionCount; i++) { + const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size); + } + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkInstanceCreateInfo(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO }); + vn_encode_VkInstanceCreateInfo_pnext(enc, val->pNext); + vn_encode_VkInstanceCreateInfo_self(enc, val); +} + +/* struct VkQueueFamilyProperties */ + +static inline size_t +vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->queueFlags); + size += vn_sizeof_uint32_t(&val->queueCount); + size += vn_sizeof_uint32_t(&val->timestampValidBits); + size += vn_sizeof_VkExtent3D(&val->minImageTransferGranularity); + return size; +} + +static inline void +vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder *dec, VkQueueFamilyProperties *val) +{ + vn_decode_VkFlags(dec, &val->queueFlags); + vn_decode_uint32_t(dec, &val->queueCount); + vn_decode_uint32_t(dec, &val->timestampValidBits); + vn_decode_VkExtent3D(dec, &val->minImageTransferGranularity); +} + +static inline size_t +vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties *val) +{ + size_t size = 0; + /* skip val->queueFlags */ + /* skip val->queueCount */ + /* skip val->timestampValidBits */ + size += vn_sizeof_VkExtent3D_partial(&val->minImageTransferGranularity); + return size; +} + +static inline void +vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties *val) +{ + /* skip val->queueFlags */ + /* skip val->queueCount */ + /* skip val->timestampValidBits */ + vn_encode_VkExtent3D_partial(enc, &val->minImageTransferGranularity); +} + +/* struct VkMemoryType */ + +static inline size_t +vn_sizeof_VkMemoryType(const VkMemoryType *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->propertyFlags); + size += vn_sizeof_uint32_t(&val->heapIndex); + return size; +} + +static inline void +vn_decode_VkMemoryType(struct vn_cs_decoder *dec, VkMemoryType *val) +{ + vn_decode_VkFlags(dec, &val->propertyFlags); + vn_decode_uint32_t(dec, &val->heapIndex); +} + +static inline size_t +vn_sizeof_VkMemoryType_partial(const VkMemoryType *val) +{ + size_t size = 0; + /* skip val->propertyFlags */ + /* skip val->heapIndex */ + return size; +} + +static inline void +vn_encode_VkMemoryType_partial(struct vn_cs_encoder *enc, const VkMemoryType *val) +{ + /* skip val->propertyFlags */ + /* skip val->heapIndex */ +} + +/* struct VkMemoryHeap */ + +static inline size_t +vn_sizeof_VkMemoryHeap(const VkMemoryHeap *val) +{ + size_t size = 0; + size += vn_sizeof_VkDeviceSize(&val->size); + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline void +vn_decode_VkMemoryHeap(struct vn_cs_decoder *dec, VkMemoryHeap *val) +{ + vn_decode_VkDeviceSize(dec, &val->size); + vn_decode_VkFlags(dec, &val->flags); +} + +static inline size_t +vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap *val) +{ + size_t size = 0; + /* skip val->size */ + /* skip val->flags */ + return size; +} + +static inline void +vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder *enc, const VkMemoryHeap *val) +{ + /* skip val->size */ + /* skip val->flags */ +} + +/* struct VkPhysicalDeviceMemoryProperties */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->memoryTypeCount); + size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES); + for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) + size += vn_sizeof_VkMemoryType(&val->memoryTypes[i]); + size += vn_sizeof_uint32_t(&val->memoryHeapCount); + size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS); + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) + size += vn_sizeof_VkMemoryHeap(&val->memoryHeaps[i]); + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties *val) +{ + vn_decode_uint32_t(dec, &val->memoryTypeCount); + { + vn_decode_array_size(dec, VK_MAX_MEMORY_TYPES); + for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) + vn_decode_VkMemoryType(dec, &val->memoryTypes[i]); + } + vn_decode_uint32_t(dec, &val->memoryHeapCount); + { + vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS); + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) + vn_decode_VkMemoryHeap(dec, &val->memoryHeaps[i]); + } +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties *val) +{ + size_t size = 0; + /* skip val->memoryTypeCount */ + size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES); + for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) + size += vn_sizeof_VkMemoryType_partial(&val->memoryTypes[i]); + /* skip val->memoryHeapCount */ + size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS); + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) + size += vn_sizeof_VkMemoryHeap_partial(&val->memoryHeaps[i]); + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties *val) +{ + /* skip val->memoryTypeCount */ + vn_encode_array_size(enc, VK_MAX_MEMORY_TYPES); + for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) + vn_encode_VkMemoryType_partial(enc, &val->memoryTypes[i]); + /* skip val->memoryHeapCount */ + vn_encode_array_size(enc, VK_MAX_MEMORY_HEAPS); + for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) + vn_encode_VkMemoryHeap_partial(enc, &val->memoryHeaps[i]); +} + +/* struct VkExportMemoryAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkExportMemoryAllocateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExportMemoryAllocateInfo_self(const VkExportMemoryAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->handleTypes); + return size; +} + +static inline size_t +vn_sizeof_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExportMemoryAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkExportMemoryAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkExportMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExportMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->handleTypes); +} + +static inline void +vn_encode_VkExportMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkExportMemoryAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO }); + vn_encode_VkExportMemoryAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkExportMemoryAllocateInfo_self(enc, val); +} + +/* struct VkMemoryAllocateFlagsInfo chain */ + +static inline size_t +vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryAllocateFlagsInfo_self(const VkMemoryAllocateFlagsInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->deviceMask); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryAllocateFlagsInfo_pnext(val->pNext); + size += vn_sizeof_VkMemoryAllocateFlagsInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkMemoryAllocateFlagsInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryAllocateFlagsInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->deviceMask); +} + +static inline void +vn_encode_VkMemoryAllocateFlagsInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagsInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO }); + vn_encode_VkMemoryAllocateFlagsInfo_pnext(enc, val->pNext); + vn_encode_VkMemoryAllocateFlagsInfo_self(enc, val); +} + +/* struct VkMemoryDedicatedAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedAllocateInfo_self(const VkMemoryDedicatedAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_VkBuffer(&val->buffer); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryDedicatedAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkMemoryDedicatedAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryDedicatedAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->image); + vn_encode_VkBuffer(enc, &val->buffer); +} + +static inline void +vn_encode_VkMemoryDedicatedAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryDedicatedAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO }); + vn_encode_VkMemoryDedicatedAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, val); +} + +/* struct VkMemoryOpaqueCaptureAddressAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(const VkMemoryOpaqueCaptureAddressAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint64_t(enc, &val->opaqueCaptureAddress); +} + +static inline void +vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryOpaqueCaptureAddressAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO }); + vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, val); +} + +/* struct VkMemoryAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkMemoryAllocateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkExportMemoryAllocateInfo_self((const VkExportMemoryAllocateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkMemoryAllocateFlagsInfo_self((const VkMemoryAllocateFlagsInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkMemoryDedicatedAllocateInfo_self((const VkMemoryDedicatedAllocateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkMemoryAllocateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkMemoryOpaqueCaptureAddressAllocateInfo_self((const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryAllocateInfo_self(const VkMemoryAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceSize(&val->allocationSize); + size += vn_sizeof_uint32_t(&val->memoryTypeIndex); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryAllocateInfo(const VkMemoryAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkMemoryAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkMemoryAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext); + vn_encode_VkExportMemoryAllocateInfo_self(enc, (const VkExportMemoryAllocateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext); + vn_encode_VkMemoryAllocateFlagsInfo_self(enc, (const VkMemoryAllocateFlagsInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext); + vn_encode_VkMemoryDedicatedAllocateInfo_self(enc, (const VkMemoryDedicatedAllocateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkMemoryAllocateInfo_pnext(enc, pnext->pNext); + vn_encode_VkMemoryOpaqueCaptureAddressAllocateInfo_self(enc, (const VkMemoryOpaqueCaptureAddressAllocateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryAllocateInfo_self(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDeviceSize(enc, &val->allocationSize); + vn_encode_uint32_t(enc, &val->memoryTypeIndex); +} + +static inline void +vn_encode_VkMemoryAllocateInfo(struct vn_cs_encoder *enc, const VkMemoryAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO }); + vn_encode_VkMemoryAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkMemoryAllocateInfo_self(enc, val); +} + +/* struct VkMemoryRequirements */ + +static inline size_t +vn_sizeof_VkMemoryRequirements(const VkMemoryRequirements *val) +{ + size_t size = 0; + size += vn_sizeof_VkDeviceSize(&val->size); + size += vn_sizeof_VkDeviceSize(&val->alignment); + size += vn_sizeof_uint32_t(&val->memoryTypeBits); + return size; +} + +static inline void +vn_decode_VkMemoryRequirements(struct vn_cs_decoder *dec, VkMemoryRequirements *val) +{ + vn_decode_VkDeviceSize(dec, &val->size); + vn_decode_VkDeviceSize(dec, &val->alignment); + vn_decode_uint32_t(dec, &val->memoryTypeBits); +} + +static inline size_t +vn_sizeof_VkMemoryRequirements_partial(const VkMemoryRequirements *val) +{ + size_t size = 0; + /* skip val->size */ + /* skip val->alignment */ + /* skip val->memoryTypeBits */ + return size; +} + +static inline void +vn_encode_VkMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements *val) +{ + /* skip val->size */ + /* skip val->alignment */ + /* skip val->memoryTypeBits */ +} + +/* struct VkSparseImageFormatProperties */ + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties(const VkSparseImageFormatProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->aspectMask); + size += vn_sizeof_VkExtent3D(&val->imageGranularity); + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline void +vn_decode_VkSparseImageFormatProperties(struct vn_cs_decoder *dec, VkSparseImageFormatProperties *val) +{ + vn_decode_VkFlags(dec, &val->aspectMask); + vn_decode_VkExtent3D(dec, &val->imageGranularity); + vn_decode_VkFlags(dec, &val->flags); +} + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties_partial(const VkSparseImageFormatProperties *val) +{ + size_t size = 0; + /* skip val->aspectMask */ + size += vn_sizeof_VkExtent3D_partial(&val->imageGranularity); + /* skip val->flags */ + return size; +} + +static inline void +vn_encode_VkSparseImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties *val) +{ + /* skip val->aspectMask */ + vn_encode_VkExtent3D_partial(enc, &val->imageGranularity); + /* skip val->flags */ +} + +/* struct VkSparseImageMemoryRequirements */ + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements *val) +{ + size_t size = 0; + size += vn_sizeof_VkSparseImageFormatProperties(&val->formatProperties); + size += vn_sizeof_uint32_t(&val->imageMipTailFirstLod); + size += vn_sizeof_VkDeviceSize(&val->imageMipTailSize); + size += vn_sizeof_VkDeviceSize(&val->imageMipTailOffset); + size += vn_sizeof_VkDeviceSize(&val->imageMipTailStride); + return size; +} + +static inline void +vn_decode_VkSparseImageMemoryRequirements(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements *val) +{ + vn_decode_VkSparseImageFormatProperties(dec, &val->formatProperties); + vn_decode_uint32_t(dec, &val->imageMipTailFirstLod); + vn_decode_VkDeviceSize(dec, &val->imageMipTailSize); + vn_decode_VkDeviceSize(dec, &val->imageMipTailOffset); + vn_decode_VkDeviceSize(dec, &val->imageMipTailStride); +} + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements_partial(const VkSparseImageMemoryRequirements *val) +{ + size_t size = 0; + size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->formatProperties); + /* skip val->imageMipTailFirstLod */ + /* skip val->imageMipTailSize */ + /* skip val->imageMipTailOffset */ + /* skip val->imageMipTailStride */ + return size; +} + +static inline void +vn_encode_VkSparseImageMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements *val) +{ + vn_encode_VkSparseImageFormatProperties_partial(enc, &val->formatProperties); + /* skip val->imageMipTailFirstLod */ + /* skip val->imageMipTailSize */ + /* skip val->imageMipTailOffset */ + /* skip val->imageMipTailStride */ +} + +/* struct VkMappedMemoryRange chain */ + +static inline size_t +vn_sizeof_VkMappedMemoryRange_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMappedMemoryRange_self(const VkMappedMemoryRange *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceMemory(&val->memory); + size += vn_sizeof_VkDeviceSize(&val->offset); + size += vn_sizeof_VkDeviceSize(&val->size); + return size; +} + +static inline size_t +vn_sizeof_VkMappedMemoryRange(const VkMappedMemoryRange *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMappedMemoryRange_pnext(val->pNext); + size += vn_sizeof_VkMappedMemoryRange_self(val); + + return size; +} + +static inline void +vn_encode_VkMappedMemoryRange_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMappedMemoryRange_self(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDeviceMemory(enc, &val->memory); + vn_encode_VkDeviceSize(enc, &val->offset); + vn_encode_VkDeviceSize(enc, &val->size); +} + +static inline void +vn_encode_VkMappedMemoryRange(struct vn_cs_encoder *enc, const VkMappedMemoryRange *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE }); + vn_encode_VkMappedMemoryRange_pnext(enc, val->pNext); + vn_encode_VkMappedMemoryRange_self(enc, val); +} + +static inline void +vn_decode_VkMappedMemoryRange_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkMappedMemoryRange_self(struct vn_cs_decoder *dec, VkMappedMemoryRange *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkDeviceMemory(dec, &val->memory); + vn_decode_VkDeviceSize(dec, &val->offset); + vn_decode_VkDeviceSize(dec, &val->size); +} + +static inline void +vn_decode_VkMappedMemoryRange(struct vn_cs_decoder *dec, VkMappedMemoryRange *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE); + + assert(val->sType == stype); + vn_decode_VkMappedMemoryRange_pnext(dec, val->pNext); + vn_decode_VkMappedMemoryRange_self(dec, val); +} + +/* struct VkFormatProperties */ + +static inline size_t +vn_sizeof_VkFormatProperties(const VkFormatProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->linearTilingFeatures); + size += vn_sizeof_VkFlags(&val->optimalTilingFeatures); + size += vn_sizeof_VkFlags(&val->bufferFeatures); + return size; +} + +static inline void +vn_decode_VkFormatProperties(struct vn_cs_decoder *dec, VkFormatProperties *val) +{ + vn_decode_VkFlags(dec, &val->linearTilingFeatures); + vn_decode_VkFlags(dec, &val->optimalTilingFeatures); + vn_decode_VkFlags(dec, &val->bufferFeatures); +} + +static inline size_t +vn_sizeof_VkFormatProperties_partial(const VkFormatProperties *val) +{ + size_t size = 0; + /* skip val->linearTilingFeatures */ + /* skip val->optimalTilingFeatures */ + /* skip val->bufferFeatures */ + return size; +} + +static inline void +vn_encode_VkFormatProperties_partial(struct vn_cs_encoder *enc, const VkFormatProperties *val) +{ + /* skip val->linearTilingFeatures */ + /* skip val->optimalTilingFeatures */ + /* skip val->bufferFeatures */ +} + +/* struct VkImageFormatProperties */ + +static inline size_t +vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkExtent3D(&val->maxExtent); + size += vn_sizeof_uint32_t(&val->maxMipLevels); + size += vn_sizeof_uint32_t(&val->maxArrayLayers); + size += vn_sizeof_VkFlags(&val->sampleCounts); + size += vn_sizeof_VkDeviceSize(&val->maxResourceSize); + return size; +} + +static inline void +vn_decode_VkImageFormatProperties(struct vn_cs_decoder *dec, VkImageFormatProperties *val) +{ + vn_decode_VkExtent3D(dec, &val->maxExtent); + vn_decode_uint32_t(dec, &val->maxMipLevels); + vn_decode_uint32_t(dec, &val->maxArrayLayers); + vn_decode_VkFlags(dec, &val->sampleCounts); + vn_decode_VkDeviceSize(dec, &val->maxResourceSize); +} + +static inline size_t +vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkExtent3D_partial(&val->maxExtent); + /* skip val->maxMipLevels */ + /* skip val->maxArrayLayers */ + /* skip val->sampleCounts */ + /* skip val->maxResourceSize */ + return size; +} + +static inline void +vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties *val) +{ + vn_encode_VkExtent3D_partial(enc, &val->maxExtent); + /* skip val->maxMipLevels */ + /* skip val->maxArrayLayers */ + /* skip val->sampleCounts */ + /* skip val->maxResourceSize */ +} + +/* struct VkDescriptorBufferInfo */ + +static inline size_t +vn_sizeof_VkDescriptorBufferInfo(const VkDescriptorBufferInfo *val) +{ + size_t size = 0; + size += vn_sizeof_VkBuffer(&val->buffer); + size += vn_sizeof_VkDeviceSize(&val->offset); + size += vn_sizeof_VkDeviceSize(&val->range); + return size; +} + +static inline void +vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBufferInfo *val) +{ + vn_encode_VkBuffer(enc, &val->buffer); + vn_encode_VkDeviceSize(enc, &val->offset); + vn_encode_VkDeviceSize(enc, &val->range); +} + +/* struct VkDescriptorImageInfo */ + +static inline size_t +vn_sizeof_VkDescriptorImageInfo(const VkDescriptorImageInfo *val) +{ + size_t size = 0; + size += vn_sizeof_VkSampler(&val->sampler); + size += vn_sizeof_VkImageView(&val->imageView); + size += vn_sizeof_VkImageLayout(&val->imageLayout); + return size; +} + +static inline void +vn_encode_VkDescriptorImageInfo(struct vn_cs_encoder *enc, const VkDescriptorImageInfo *val) +{ + vn_encode_VkSampler(enc, &val->sampler); + vn_encode_VkImageView(enc, &val->imageView); + vn_encode_VkImageLayout(enc, &val->imageLayout); +} + +/* struct VkWriteDescriptorSet chain */ + +static inline size_t +vn_sizeof_VkWriteDescriptorSet_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkWriteDescriptorSet_self(const VkWriteDescriptorSet *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDescriptorSet(&val->dstSet); + size += vn_sizeof_uint32_t(&val->dstBinding); + size += vn_sizeof_uint32_t(&val->dstArrayElement); + size += vn_sizeof_uint32_t(&val->descriptorCount); + size += vn_sizeof_VkDescriptorType(&val->descriptorType); + if (val->pImageInfo) { + size += vn_sizeof_array_size(val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + size += vn_sizeof_VkDescriptorImageInfo(&val->pImageInfo[i]); + } else { + size += vn_sizeof_array_size(0); + } + if (val->pBufferInfo) { + size += vn_sizeof_array_size(val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + size += vn_sizeof_VkDescriptorBufferInfo(&val->pBufferInfo[i]); + } else { + size += vn_sizeof_array_size(0); + } + if (val->pTexelBufferView) { + size += vn_sizeof_array_size(val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + size += vn_sizeof_VkBufferView(&val->pTexelBufferView[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkWriteDescriptorSet_pnext(val->pNext); + size += vn_sizeof_VkWriteDescriptorSet_self(val); + + return size; +} + +static inline void +vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkWriteDescriptorSet_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDescriptorSet(enc, &val->dstSet); + vn_encode_uint32_t(enc, &val->dstBinding); + vn_encode_uint32_t(enc, &val->dstArrayElement); + vn_encode_uint32_t(enc, &val->descriptorCount); + vn_encode_VkDescriptorType(enc, &val->descriptorType); + if (val->pImageInfo) { + vn_encode_array_size(enc, val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + vn_encode_VkDescriptorImageInfo(enc, &val->pImageInfo[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (val->pBufferInfo) { + vn_encode_array_size(enc, val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + vn_encode_VkDescriptorBufferInfo(enc, &val->pBufferInfo[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (val->pTexelBufferView) { + vn_encode_array_size(enc, val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + vn_encode_VkBufferView(enc, &val->pTexelBufferView[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkWriteDescriptorSet(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET }); + vn_encode_VkWriteDescriptorSet_pnext(enc, val->pNext); + vn_encode_VkWriteDescriptorSet_self(enc, val); +} + +/* struct VkCopyDescriptorSet chain */ + +static inline size_t +vn_sizeof_VkCopyDescriptorSet_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCopyDescriptorSet_self(const VkCopyDescriptorSet *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDescriptorSet(&val->srcSet); + size += vn_sizeof_uint32_t(&val->srcBinding); + size += vn_sizeof_uint32_t(&val->srcArrayElement); + size += vn_sizeof_VkDescriptorSet(&val->dstSet); + size += vn_sizeof_uint32_t(&val->dstBinding); + size += vn_sizeof_uint32_t(&val->dstArrayElement); + size += vn_sizeof_uint32_t(&val->descriptorCount); + return size; +} + +static inline size_t +vn_sizeof_VkCopyDescriptorSet(const VkCopyDescriptorSet *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCopyDescriptorSet_pnext(val->pNext); + size += vn_sizeof_VkCopyDescriptorSet_self(val); + + return size; +} + +static inline void +vn_encode_VkCopyDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCopyDescriptorSet_self(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDescriptorSet(enc, &val->srcSet); + vn_encode_uint32_t(enc, &val->srcBinding); + vn_encode_uint32_t(enc, &val->srcArrayElement); + vn_encode_VkDescriptorSet(enc, &val->dstSet); + vn_encode_uint32_t(enc, &val->dstBinding); + vn_encode_uint32_t(enc, &val->dstArrayElement); + vn_encode_uint32_t(enc, &val->descriptorCount); +} + +static inline void +vn_encode_VkCopyDescriptorSet(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET }); + vn_encode_VkCopyDescriptorSet_pnext(enc, val->pNext); + vn_encode_VkCopyDescriptorSet_self(enc, val); +} + +/* struct VkExternalMemoryBufferCreateInfo chain */ + +static inline size_t +vn_sizeof_VkExternalMemoryBufferCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalMemoryBufferCreateInfo_self(const VkExternalMemoryBufferCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->handleTypes); + return size; +} + +static inline size_t +vn_sizeof_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalMemoryBufferCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkExternalMemoryBufferCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkExternalMemoryBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExternalMemoryBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->handleTypes); +} + +static inline void +vn_encode_VkExternalMemoryBufferCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO }); + vn_encode_VkExternalMemoryBufferCreateInfo_pnext(enc, val->pNext); + vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, val); +} + +/* struct VkBufferOpaqueCaptureAddressCreateInfo chain */ + +static inline size_t +vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self(const VkBufferOpaqueCaptureAddressCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint64_t(&val->opaqueCaptureAddress); + return size; +} + +static inline size_t +vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint64_t(enc, &val->opaqueCaptureAddress); +} + +static inline void +vn_encode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO }); + vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(enc, val->pNext); + vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, val); +} + +/* struct VkBufferCreateInfo chain */ + +static inline size_t +vn_sizeof_VkBufferCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkExternalMemoryBufferCreateInfo_self((const VkExternalMemoryBufferCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkBufferOpaqueCaptureAddressCreateInfo_self((const VkBufferOpaqueCaptureAddressCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferCreateInfo_self(const VkBufferCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkDeviceSize(&val->size); + size += vn_sizeof_VkFlags(&val->usage); + size += vn_sizeof_VkSharingMode(&val->sharingMode); + size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount); + if (val->pQueueFamilyIndices) { + size += vn_sizeof_array_size(val->queueFamilyIndexCount); + size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkBufferCreateInfo(const VkBufferCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkBufferCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, (const VkExternalMemoryBufferCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, (const VkBufferOpaqueCaptureAddressCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkDeviceSize(enc, &val->size); + vn_encode_VkFlags(enc, &val->usage); + vn_encode_VkSharingMode(enc, &val->sharingMode); + vn_encode_uint32_t(enc, &val->queueFamilyIndexCount); + if (val->pQueueFamilyIndices) { + vn_encode_array_size(enc, val->queueFamilyIndexCount); + vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkBufferCreateInfo(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO }); + vn_encode_VkBufferCreateInfo_pnext(enc, val->pNext); + vn_encode_VkBufferCreateInfo_self(enc, val); +} + +/* struct VkBufferViewCreateInfo chain */ + +static inline size_t +vn_sizeof_VkBufferViewCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferViewCreateInfo_self(const VkBufferViewCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkBuffer(&val->buffer); + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkDeviceSize(&val->offset); + size += vn_sizeof_VkDeviceSize(&val->range); + return size; +} + +static inline size_t +vn_sizeof_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferViewCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkBufferViewCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferViewCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkBuffer(enc, &val->buffer); + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkDeviceSize(enc, &val->offset); + vn_encode_VkDeviceSize(enc, &val->range); +} + +static inline void +vn_encode_VkBufferViewCreateInfo(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO }); + vn_encode_VkBufferViewCreateInfo_pnext(enc, val->pNext); + vn_encode_VkBufferViewCreateInfo_self(enc, val); +} + +/* struct VkImageSubresource */ + +static inline size_t +vn_sizeof_VkImageSubresource(const VkImageSubresource *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->aspectMask); + size += vn_sizeof_uint32_t(&val->mipLevel); + size += vn_sizeof_uint32_t(&val->arrayLayer); + return size; +} + +static inline void +vn_encode_VkImageSubresource(struct vn_cs_encoder *enc, const VkImageSubresource *val) +{ + vn_encode_VkFlags(enc, &val->aspectMask); + vn_encode_uint32_t(enc, &val->mipLevel); + vn_encode_uint32_t(enc, &val->arrayLayer); +} + +/* struct VkImageSubresourceLayers */ + +static inline size_t +vn_sizeof_VkImageSubresourceLayers(const VkImageSubresourceLayers *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->aspectMask); + size += vn_sizeof_uint32_t(&val->mipLevel); + size += vn_sizeof_uint32_t(&val->baseArrayLayer); + size += vn_sizeof_uint32_t(&val->layerCount); + return size; +} + +static inline void +vn_encode_VkImageSubresourceLayers(struct vn_cs_encoder *enc, const VkImageSubresourceLayers *val) +{ + vn_encode_VkFlags(enc, &val->aspectMask); + vn_encode_uint32_t(enc, &val->mipLevel); + vn_encode_uint32_t(enc, &val->baseArrayLayer); + vn_encode_uint32_t(enc, &val->layerCount); +} + +/* struct VkImageSubresourceRange */ + +static inline size_t +vn_sizeof_VkImageSubresourceRange(const VkImageSubresourceRange *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->aspectMask); + size += vn_sizeof_uint32_t(&val->baseMipLevel); + size += vn_sizeof_uint32_t(&val->levelCount); + size += vn_sizeof_uint32_t(&val->baseArrayLayer); + size += vn_sizeof_uint32_t(&val->layerCount); + return size; +} + +static inline void +vn_encode_VkImageSubresourceRange(struct vn_cs_encoder *enc, const VkImageSubresourceRange *val) +{ + vn_encode_VkFlags(enc, &val->aspectMask); + vn_encode_uint32_t(enc, &val->baseMipLevel); + vn_encode_uint32_t(enc, &val->levelCount); + vn_encode_uint32_t(enc, &val->baseArrayLayer); + vn_encode_uint32_t(enc, &val->layerCount); +} + +/* struct VkMemoryBarrier chain */ + +static inline size_t +vn_sizeof_VkMemoryBarrier_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryBarrier_self(const VkMemoryBarrier *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->srcAccessMask); + size += vn_sizeof_VkFlags(&val->dstAccessMask); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryBarrier(const VkMemoryBarrier *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryBarrier_pnext(val->pNext); + size += vn_sizeof_VkMemoryBarrier_self(val); + + return size; +} + +static inline void +vn_encode_VkMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryBarrier_self(struct vn_cs_encoder *enc, const VkMemoryBarrier *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->srcAccessMask); + vn_encode_VkFlags(enc, &val->dstAccessMask); +} + +static inline void +vn_encode_VkMemoryBarrier(struct vn_cs_encoder *enc, const VkMemoryBarrier *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_BARRIER); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_BARRIER }); + vn_encode_VkMemoryBarrier_pnext(enc, val->pNext); + vn_encode_VkMemoryBarrier_self(enc, val); +} + +/* struct VkBufferMemoryBarrier chain */ + +static inline size_t +vn_sizeof_VkBufferMemoryBarrier_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferMemoryBarrier_self(const VkBufferMemoryBarrier *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->srcAccessMask); + size += vn_sizeof_VkFlags(&val->dstAccessMask); + size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex); + size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex); + size += vn_sizeof_VkBuffer(&val->buffer); + size += vn_sizeof_VkDeviceSize(&val->offset); + size += vn_sizeof_VkDeviceSize(&val->size); + return size; +} + +static inline size_t +vn_sizeof_VkBufferMemoryBarrier(const VkBufferMemoryBarrier *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferMemoryBarrier_pnext(val->pNext); + size += vn_sizeof_VkBufferMemoryBarrier_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferMemoryBarrier_self(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->srcAccessMask); + vn_encode_VkFlags(enc, &val->dstAccessMask); + vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex); + vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex); + vn_encode_VkBuffer(enc, &val->buffer); + vn_encode_VkDeviceSize(enc, &val->offset); + vn_encode_VkDeviceSize(enc, &val->size); +} + +static inline void +vn_encode_VkBufferMemoryBarrier(struct vn_cs_encoder *enc, const VkBufferMemoryBarrier *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER }); + vn_encode_VkBufferMemoryBarrier_pnext(enc, val->pNext); + vn_encode_VkBufferMemoryBarrier_self(enc, val); +} + +/* struct VkImageMemoryBarrier chain */ + +static inline size_t +vn_sizeof_VkImageMemoryBarrier_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageMemoryBarrier_self(const VkImageMemoryBarrier *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->srcAccessMask); + size += vn_sizeof_VkFlags(&val->dstAccessMask); + size += vn_sizeof_VkImageLayout(&val->oldLayout); + size += vn_sizeof_VkImageLayout(&val->newLayout); + size += vn_sizeof_uint32_t(&val->srcQueueFamilyIndex); + size += vn_sizeof_uint32_t(&val->dstQueueFamilyIndex); + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange); + return size; +} + +static inline size_t +vn_sizeof_VkImageMemoryBarrier(const VkImageMemoryBarrier *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageMemoryBarrier_pnext(val->pNext); + size += vn_sizeof_VkImageMemoryBarrier_self(val); + + return size; +} + +static inline void +vn_encode_VkImageMemoryBarrier_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageMemoryBarrier_self(struct vn_cs_encoder *enc, const VkImageMemoryBarrier *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->srcAccessMask); + vn_encode_VkFlags(enc, &val->dstAccessMask); + vn_encode_VkImageLayout(enc, &val->oldLayout); + vn_encode_VkImageLayout(enc, &val->newLayout); + vn_encode_uint32_t(enc, &val->srcQueueFamilyIndex); + vn_encode_uint32_t(enc, &val->dstQueueFamilyIndex); + vn_encode_VkImage(enc, &val->image); + vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange); +} + +static inline void +vn_encode_VkImageMemoryBarrier(struct vn_cs_encoder *enc, const VkImageMemoryBarrier *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER }); + vn_encode_VkImageMemoryBarrier_pnext(enc, val->pNext); + vn_encode_VkImageMemoryBarrier_self(enc, val); +} + +/* struct VkExternalMemoryImageCreateInfo chain */ + +static inline size_t +vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalMemoryImageCreateInfo_self(const VkExternalMemoryImageCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->handleTypes); + return size; +} + +static inline size_t +vn_sizeof_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkExternalMemoryImageCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->handleTypes); +} + +static inline void +vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO }); + vn_encode_VkExternalMemoryImageCreateInfo_pnext(enc, val->pNext); + vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val); +} + +/* struct VkImageFormatListCreateInfo chain */ + +static inline size_t +vn_sizeof_VkImageFormatListCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageFormatListCreateInfo_self(const VkImageFormatListCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->viewFormatCount); + if (val->pViewFormats) { + size += vn_sizeof_array_size(val->viewFormatCount); + size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageFormatListCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkImageFormatListCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkImageFormatListCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageFormatListCreateInfo_self(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->viewFormatCount); + if (val->pViewFormats) { + vn_encode_array_size(enc, val->viewFormatCount); + vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO }); + vn_encode_VkImageFormatListCreateInfo_pnext(enc, val->pNext); + vn_encode_VkImageFormatListCreateInfo_self(enc, val); +} + +/* struct VkImageDrmFormatModifierListCreateInfoEXT chain */ + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(const VkImageDrmFormatModifierListCreateInfoEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->drmFormatModifierCount); + if (val->pDrmFormatModifiers) { + size += vn_sizeof_array_size(val->drmFormatModifierCount); + size += vn_sizeof_uint64_t_array(val->pDrmFormatModifiers, val->drmFormatModifierCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(val->pNext); + size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->drmFormatModifierCount); + if (val->pDrmFormatModifiers) { + vn_encode_array_size(enc, val->drmFormatModifierCount); + vn_encode_uint64_t_array(enc, val->pDrmFormatModifiers, val->drmFormatModifierCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT }); + vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(enc, val->pNext); + vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val); +} + +/* struct VkSubresourceLayout */ + +static inline size_t +vn_sizeof_VkSubresourceLayout(const VkSubresourceLayout *val) +{ + size_t size = 0; + size += vn_sizeof_VkDeviceSize(&val->offset); + size += vn_sizeof_VkDeviceSize(&val->size); + size += vn_sizeof_VkDeviceSize(&val->rowPitch); + size += vn_sizeof_VkDeviceSize(&val->arrayPitch); + size += vn_sizeof_VkDeviceSize(&val->depthPitch); + return size; +} + +static inline void +vn_encode_VkSubresourceLayout(struct vn_cs_encoder *enc, const VkSubresourceLayout *val) +{ + vn_encode_VkDeviceSize(enc, &val->offset); + vn_encode_VkDeviceSize(enc, &val->size); + vn_encode_VkDeviceSize(enc, &val->rowPitch); + vn_encode_VkDeviceSize(enc, &val->arrayPitch); + vn_encode_VkDeviceSize(enc, &val->depthPitch); +} + +static inline void +vn_decode_VkSubresourceLayout(struct vn_cs_decoder *dec, VkSubresourceLayout *val) +{ + vn_decode_VkDeviceSize(dec, &val->offset); + vn_decode_VkDeviceSize(dec, &val->size); + vn_decode_VkDeviceSize(dec, &val->rowPitch); + vn_decode_VkDeviceSize(dec, &val->arrayPitch); + vn_decode_VkDeviceSize(dec, &val->depthPitch); +} + +static inline size_t +vn_sizeof_VkSubresourceLayout_partial(const VkSubresourceLayout *val) +{ + size_t size = 0; + /* skip val->offset */ + /* skip val->size */ + /* skip val->rowPitch */ + /* skip val->arrayPitch */ + /* skip val->depthPitch */ + return size; +} + +static inline void +vn_encode_VkSubresourceLayout_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout *val) +{ + /* skip val->offset */ + /* skip val->size */ + /* skip val->rowPitch */ + /* skip val->arrayPitch */ + /* skip val->depthPitch */ +} + +/* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */ + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint64_t(&val->drmFormatModifier); + size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount); + if (val->pPlaneLayouts) { + size += vn_sizeof_array_size(val->drmFormatModifierPlaneCount); + for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++) + size += vn_sizeof_VkSubresourceLayout(&val->pPlaneLayouts[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(val->pNext); + size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint64_t(enc, &val->drmFormatModifier); + vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount); + if (val->pPlaneLayouts) { + vn_encode_array_size(enc, val->drmFormatModifierPlaneCount); + for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++) + vn_encode_VkSubresourceLayout(enc, &val->pPlaneLayouts[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT }); + vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(enc, val->pNext); + vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val); +} + +/* struct VkImageStencilUsageCreateInfo chain */ + +static inline size_t +vn_sizeof_VkImageStencilUsageCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageStencilUsageCreateInfo_self(const VkImageStencilUsageCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->stencilUsage); + return size; +} + +static inline size_t +vn_sizeof_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageStencilUsageCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkImageStencilUsageCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageStencilUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->stencilUsage); +} + +static inline void +vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO }); + vn_encode_VkImageStencilUsageCreateInfo_pnext(enc, val->pNext); + vn_encode_VkImageStencilUsageCreateInfo_self(enc, val); +} + +/* struct VkImageCreateInfo chain */ + +static inline size_t +vn_sizeof_VkImageCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkExternalMemoryImageCreateInfo_self((const VkExternalMemoryImageCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self((const VkImageDrmFormatModifierListCreateInfoEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self((const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageCreateInfo_self(const VkImageCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkImageType(&val->imageType); + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkExtent3D(&val->extent); + size += vn_sizeof_uint32_t(&val->mipLevels); + size += vn_sizeof_uint32_t(&val->arrayLayers); + size += vn_sizeof_VkSampleCountFlagBits(&val->samples); + size += vn_sizeof_VkImageTiling(&val->tiling); + size += vn_sizeof_VkFlags(&val->usage); + size += vn_sizeof_VkSharingMode(&val->sharingMode); + size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount); + if (val->pQueueFamilyIndices) { + size += vn_sizeof_array_size(val->queueFamilyIndexCount); + size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_VkImageLayout(&val->initialLayout); + return size; +} + +static inline size_t +vn_sizeof_VkImageCreateInfo(const VkImageCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkImageCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkExternalMemoryImageCreateInfo_self(enc, (const VkExternalMemoryImageCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierListCreateInfoEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkImageType(enc, &val->imageType); + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkExtent3D(enc, &val->extent); + vn_encode_uint32_t(enc, &val->mipLevels); + vn_encode_uint32_t(enc, &val->arrayLayers); + vn_encode_VkSampleCountFlagBits(enc, &val->samples); + vn_encode_VkImageTiling(enc, &val->tiling); + vn_encode_VkFlags(enc, &val->usage); + vn_encode_VkSharingMode(enc, &val->sharingMode); + vn_encode_uint32_t(enc, &val->queueFamilyIndexCount); + if (val->pQueueFamilyIndices) { + vn_encode_array_size(enc, val->queueFamilyIndexCount); + vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkImageLayout(enc, &val->initialLayout); +} + +static inline void +vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO }); + vn_encode_VkImageCreateInfo_pnext(enc, val->pNext); + vn_encode_VkImageCreateInfo_self(enc, val); +} + +/* struct VkImageViewUsageCreateInfo chain */ + +static inline size_t +vn_sizeof_VkImageViewUsageCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageViewUsageCreateInfo_self(const VkImageViewUsageCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->usage); + return size; +} + +static inline size_t +vn_sizeof_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageViewUsageCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkImageViewUsageCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkImageViewUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageViewUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->usage); +} + +static inline void +vn_encode_VkImageViewUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO }); + vn_encode_VkImageViewUsageCreateInfo_pnext(enc, val->pNext); + vn_encode_VkImageViewUsageCreateInfo_self(enc, val); +} + +/* struct VkSamplerYcbcrConversionInfo chain */ + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionInfo_self(const VkSamplerYcbcrConversionInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSamplerYcbcrConversion(&val->conversion); + return size; +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(val->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSamplerYcbcrConversionInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSamplerYcbcrConversionInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSamplerYcbcrConversion(enc, &val->conversion); +} + +static inline void +vn_encode_VkSamplerYcbcrConversionInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO }); + vn_encode_VkSamplerYcbcrConversionInfo_pnext(enc, val->pNext); + vn_encode_VkSamplerYcbcrConversionInfo_self(enc, val); +} + +/* struct VkImageViewCreateInfo chain */ + +static inline size_t +vn_sizeof_VkImageViewCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkImageViewUsageCreateInfo_self((const VkImageViewUsageCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageViewCreateInfo_self(const VkImageViewCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_VkImageViewType(&val->viewType); + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkComponentMapping(&val->components); + size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange); + return size; +} + +static inline size_t +vn_sizeof_VkImageViewCreateInfo(const VkImageViewCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageViewCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkImageViewCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkImageViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkImageViewUsageCreateInfo_self(enc, (const VkImageViewUsageCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageViewCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkImage(enc, &val->image); + vn_encode_VkImageViewType(enc, &val->viewType); + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkComponentMapping(enc, &val->components); + vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange); +} + +static inline void +vn_encode_VkImageViewCreateInfo(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO }); + vn_encode_VkImageViewCreateInfo_pnext(enc, val->pNext); + vn_encode_VkImageViewCreateInfo_self(enc, val); +} + +/* struct VkBufferCopy */ + +static inline size_t +vn_sizeof_VkBufferCopy(const VkBufferCopy *val) +{ + size_t size = 0; + size += vn_sizeof_VkDeviceSize(&val->srcOffset); + size += vn_sizeof_VkDeviceSize(&val->dstOffset); + size += vn_sizeof_VkDeviceSize(&val->size); + return size; +} + +static inline void +vn_encode_VkBufferCopy(struct vn_cs_encoder *enc, const VkBufferCopy *val) +{ + vn_encode_VkDeviceSize(enc, &val->srcOffset); + vn_encode_VkDeviceSize(enc, &val->dstOffset); + vn_encode_VkDeviceSize(enc, &val->size); +} + +/* struct VkSparseMemoryBind */ + +static inline size_t +vn_sizeof_VkSparseMemoryBind(const VkSparseMemoryBind *val) +{ + size_t size = 0; + size += vn_sizeof_VkDeviceSize(&val->resourceOffset); + size += vn_sizeof_VkDeviceSize(&val->size); + size += vn_sizeof_VkDeviceMemory(&val->memory); + size += vn_sizeof_VkDeviceSize(&val->memoryOffset); + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline void +vn_encode_VkSparseMemoryBind(struct vn_cs_encoder *enc, const VkSparseMemoryBind *val) +{ + vn_encode_VkDeviceSize(enc, &val->resourceOffset); + vn_encode_VkDeviceSize(enc, &val->size); + vn_encode_VkDeviceMemory(enc, &val->memory); + vn_encode_VkDeviceSize(enc, &val->memoryOffset); + vn_encode_VkFlags(enc, &val->flags); +} + +/* struct VkSparseImageMemoryBind */ + +static inline size_t +vn_sizeof_VkSparseImageMemoryBind(const VkSparseImageMemoryBind *val) +{ + size_t size = 0; + size += vn_sizeof_VkImageSubresource(&val->subresource); + size += vn_sizeof_VkOffset3D(&val->offset); + size += vn_sizeof_VkExtent3D(&val->extent); + size += vn_sizeof_VkDeviceMemory(&val->memory); + size += vn_sizeof_VkDeviceSize(&val->memoryOffset); + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline void +vn_encode_VkSparseImageMemoryBind(struct vn_cs_encoder *enc, const VkSparseImageMemoryBind *val) +{ + vn_encode_VkImageSubresource(enc, &val->subresource); + vn_encode_VkOffset3D(enc, &val->offset); + vn_encode_VkExtent3D(enc, &val->extent); + vn_encode_VkDeviceMemory(enc, &val->memory); + vn_encode_VkDeviceSize(enc, &val->memoryOffset); + vn_encode_VkFlags(enc, &val->flags); +} + +/* struct VkSparseBufferMemoryBindInfo */ + +static inline size_t +vn_sizeof_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo *val) +{ + size_t size = 0; + size += vn_sizeof_VkBuffer(&val->buffer); + size += vn_sizeof_uint32_t(&val->bindCount); + if (val->pBinds) { + size += vn_sizeof_array_size(val->bindCount); + for (uint32_t i = 0; i < val->bindCount; i++) + size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline void +vn_encode_VkSparseBufferMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseBufferMemoryBindInfo *val) +{ + vn_encode_VkBuffer(enc, &val->buffer); + vn_encode_uint32_t(enc, &val->bindCount); + if (val->pBinds) { + vn_encode_array_size(enc, val->bindCount); + for (uint32_t i = 0; i < val->bindCount; i++) + vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +/* struct VkSparseImageOpaqueMemoryBindInfo */ + +static inline size_t +vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo *val) +{ + size_t size = 0; + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_uint32_t(&val->bindCount); + if (val->pBinds) { + size += vn_sizeof_array_size(val->bindCount); + for (uint32_t i = 0; i < val->bindCount; i++) + size += vn_sizeof_VkSparseMemoryBind(&val->pBinds[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline void +vn_encode_VkSparseImageOpaqueMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageOpaqueMemoryBindInfo *val) +{ + vn_encode_VkImage(enc, &val->image); + vn_encode_uint32_t(enc, &val->bindCount); + if (val->pBinds) { + vn_encode_array_size(enc, val->bindCount); + for (uint32_t i = 0; i < val->bindCount; i++) + vn_encode_VkSparseMemoryBind(enc, &val->pBinds[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +/* struct VkSparseImageMemoryBindInfo */ + +static inline size_t +vn_sizeof_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo *val) +{ + size_t size = 0; + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_uint32_t(&val->bindCount); + if (val->pBinds) { + size += vn_sizeof_array_size(val->bindCount); + for (uint32_t i = 0; i < val->bindCount; i++) + size += vn_sizeof_VkSparseImageMemoryBind(&val->pBinds[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline void +vn_encode_VkSparseImageMemoryBindInfo(struct vn_cs_encoder *enc, const VkSparseImageMemoryBindInfo *val) +{ + vn_encode_VkImage(enc, &val->image); + vn_encode_uint32_t(enc, &val->bindCount); + if (val->pBinds) { + vn_encode_array_size(enc, val->bindCount); + for (uint32_t i = 0; i < val->bindCount; i++) + vn_encode_VkSparseImageMemoryBind(enc, &val->pBinds[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +/* struct VkDeviceGroupBindSparseInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceGroupBindSparseInfo_self(const VkDeviceGroupBindSparseInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->resourceDeviceIndex); + size += vn_sizeof_uint32_t(&val->memoryDeviceIndex); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceGroupBindSparseInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceGroupBindSparseInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceGroupBindSparseInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceGroupBindSparseInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->resourceDeviceIndex); + vn_encode_uint32_t(enc, &val->memoryDeviceIndex); +} + +static inline void +vn_encode_VkDeviceGroupBindSparseInfo(struct vn_cs_encoder *enc, const VkDeviceGroupBindSparseInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO }); + vn_encode_VkDeviceGroupBindSparseInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceGroupBindSparseInfo_self(enc, val); +} + +/* struct VkTimelineSemaphoreSubmitInfo chain */ + +static inline size_t +vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(const VkTimelineSemaphoreSubmitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->waitSemaphoreValueCount); + if (val->pWaitSemaphoreValues) { + size += vn_sizeof_array_size(val->waitSemaphoreValueCount); + size += vn_sizeof_uint64_t_array(val->pWaitSemaphoreValues, val->waitSemaphoreValueCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->signalSemaphoreValueCount); + if (val->pSignalSemaphoreValues) { + size += vn_sizeof_array_size(val->signalSemaphoreValueCount); + size += vn_sizeof_uint64_t_array(val->pSignalSemaphoreValues, val->signalSemaphoreValueCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_pnext(val->pNext); + size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkTimelineSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->waitSemaphoreValueCount); + if (val->pWaitSemaphoreValues) { + vn_encode_array_size(enc, val->waitSemaphoreValueCount); + vn_encode_uint64_t_array(enc, val->pWaitSemaphoreValues, val->waitSemaphoreValueCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->signalSemaphoreValueCount); + if (val->pSignalSemaphoreValues) { + vn_encode_array_size(enc, val->signalSemaphoreValueCount); + vn_encode_uint64_t_array(enc, val->pSignalSemaphoreValues, val->signalSemaphoreValueCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkTimelineSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkTimelineSemaphoreSubmitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO }); + vn_encode_VkTimelineSemaphoreSubmitInfo_pnext(enc, val->pNext); + vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, val); +} + +/* struct VkBindSparseInfo chain */ + +static inline size_t +vn_sizeof_VkBindSparseInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDeviceGroupBindSparseInfo_self((const VkDeviceGroupBindSparseInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBindSparseInfo_pnext(pnext->pNext); + size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBindSparseInfo_self(const VkBindSparseInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->waitSemaphoreCount); + if (val->pWaitSemaphores) { + size += vn_sizeof_array_size(val->waitSemaphoreCount); + for (uint32_t i = 0; i < val->waitSemaphoreCount; i++) + size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->bufferBindCount); + if (val->pBufferBinds) { + size += vn_sizeof_array_size(val->bufferBindCount); + for (uint32_t i = 0; i < val->bufferBindCount; i++) + size += vn_sizeof_VkSparseBufferMemoryBindInfo(&val->pBufferBinds[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->imageOpaqueBindCount); + if (val->pImageOpaqueBinds) { + size += vn_sizeof_array_size(val->imageOpaqueBindCount); + for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++) + size += vn_sizeof_VkSparseImageOpaqueMemoryBindInfo(&val->pImageOpaqueBinds[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->imageBindCount); + if (val->pImageBinds) { + size += vn_sizeof_array_size(val->imageBindCount); + for (uint32_t i = 0; i < val->imageBindCount; i++) + size += vn_sizeof_VkSparseImageMemoryBindInfo(&val->pImageBinds[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->signalSemaphoreCount); + if (val->pSignalSemaphores) { + size += vn_sizeof_array_size(val->signalSemaphoreCount); + for (uint32_t i = 0; i < val->signalSemaphoreCount; i++) + size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkBindSparseInfo(const VkBindSparseInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBindSparseInfo_pnext(val->pNext); + size += vn_sizeof_VkBindSparseInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBindSparseInfo_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_BIND_SPARSE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext); + vn_encode_VkDeviceGroupBindSparseInfo_self(enc, (const VkDeviceGroupBindSparseInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBindSparseInfo_pnext(enc, pnext->pNext); + vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBindSparseInfo_self(struct vn_cs_encoder *enc, const VkBindSparseInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->waitSemaphoreCount); + if (val->pWaitSemaphores) { + vn_encode_array_size(enc, val->waitSemaphoreCount); + for (uint32_t i = 0; i < val->waitSemaphoreCount; i++) + vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->bufferBindCount); + if (val->pBufferBinds) { + vn_encode_array_size(enc, val->bufferBindCount); + for (uint32_t i = 0; i < val->bufferBindCount; i++) + vn_encode_VkSparseBufferMemoryBindInfo(enc, &val->pBufferBinds[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->imageOpaqueBindCount); + if (val->pImageOpaqueBinds) { + vn_encode_array_size(enc, val->imageOpaqueBindCount); + for (uint32_t i = 0; i < val->imageOpaqueBindCount; i++) + vn_encode_VkSparseImageOpaqueMemoryBindInfo(enc, &val->pImageOpaqueBinds[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->imageBindCount); + if (val->pImageBinds) { + vn_encode_array_size(enc, val->imageBindCount); + for (uint32_t i = 0; i < val->imageBindCount; i++) + vn_encode_VkSparseImageMemoryBindInfo(enc, &val->pImageBinds[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->signalSemaphoreCount); + if (val->pSignalSemaphores) { + vn_encode_array_size(enc, val->signalSemaphoreCount); + for (uint32_t i = 0; i < val->signalSemaphoreCount; i++) + vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkBindSparseInfo(struct vn_cs_encoder *enc, const VkBindSparseInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BIND_SPARSE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO }); + vn_encode_VkBindSparseInfo_pnext(enc, val->pNext); + vn_encode_VkBindSparseInfo_self(enc, val); +} + +/* struct VkImageCopy */ + +static inline size_t +vn_sizeof_VkImageCopy(const VkImageCopy *val) +{ + size_t size = 0; + size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource); + size += vn_sizeof_VkOffset3D(&val->srcOffset); + size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource); + size += vn_sizeof_VkOffset3D(&val->dstOffset); + size += vn_sizeof_VkExtent3D(&val->extent); + return size; +} + +static inline void +vn_encode_VkImageCopy(struct vn_cs_encoder *enc, const VkImageCopy *val) +{ + vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource); + vn_encode_VkOffset3D(enc, &val->srcOffset); + vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource); + vn_encode_VkOffset3D(enc, &val->dstOffset); + vn_encode_VkExtent3D(enc, &val->extent); +} + +/* struct VkImageBlit */ + +static inline size_t +vn_sizeof_VkImageBlit(const VkImageBlit *val) +{ + size_t size = 0; + size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource); + size += vn_sizeof_array_size(2); + for (uint32_t i = 0; i < 2; i++) + size += vn_sizeof_VkOffset3D(&val->srcOffsets[i]); + size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource); + size += vn_sizeof_array_size(2); + for (uint32_t i = 0; i < 2; i++) + size += vn_sizeof_VkOffset3D(&val->dstOffsets[i]); + return size; +} + +static inline void +vn_encode_VkImageBlit(struct vn_cs_encoder *enc, const VkImageBlit *val) +{ + vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource); + vn_encode_array_size(enc, 2); + for (uint32_t i = 0; i < 2; i++) + vn_encode_VkOffset3D(enc, &val->srcOffsets[i]); + vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource); + vn_encode_array_size(enc, 2); + for (uint32_t i = 0; i < 2; i++) + vn_encode_VkOffset3D(enc, &val->dstOffsets[i]); +} + +/* struct VkBufferImageCopy */ + +static inline size_t +vn_sizeof_VkBufferImageCopy(const VkBufferImageCopy *val) +{ + size_t size = 0; + size += vn_sizeof_VkDeviceSize(&val->bufferOffset); + size += vn_sizeof_uint32_t(&val->bufferRowLength); + size += vn_sizeof_uint32_t(&val->bufferImageHeight); + size += vn_sizeof_VkImageSubresourceLayers(&val->imageSubresource); + size += vn_sizeof_VkOffset3D(&val->imageOffset); + size += vn_sizeof_VkExtent3D(&val->imageExtent); + return size; +} + +static inline void +vn_encode_VkBufferImageCopy(struct vn_cs_encoder *enc, const VkBufferImageCopy *val) +{ + vn_encode_VkDeviceSize(enc, &val->bufferOffset); + vn_encode_uint32_t(enc, &val->bufferRowLength); + vn_encode_uint32_t(enc, &val->bufferImageHeight); + vn_encode_VkImageSubresourceLayers(enc, &val->imageSubresource); + vn_encode_VkOffset3D(enc, &val->imageOffset); + vn_encode_VkExtent3D(enc, &val->imageExtent); +} + +/* struct VkImageResolve */ + +static inline size_t +vn_sizeof_VkImageResolve(const VkImageResolve *val) +{ + size_t size = 0; + size += vn_sizeof_VkImageSubresourceLayers(&val->srcSubresource); + size += vn_sizeof_VkOffset3D(&val->srcOffset); + size += vn_sizeof_VkImageSubresourceLayers(&val->dstSubresource); + size += vn_sizeof_VkOffset3D(&val->dstOffset); + size += vn_sizeof_VkExtent3D(&val->extent); + return size; +} + +static inline void +vn_encode_VkImageResolve(struct vn_cs_encoder *enc, const VkImageResolve *val) +{ + vn_encode_VkImageSubresourceLayers(enc, &val->srcSubresource); + vn_encode_VkOffset3D(enc, &val->srcOffset); + vn_encode_VkImageSubresourceLayers(enc, &val->dstSubresource); + vn_encode_VkOffset3D(enc, &val->dstOffset); + vn_encode_VkExtent3D(enc, &val->extent); +} + +/* struct VkShaderModuleCreateInfo chain */ + +static inline size_t +vn_sizeof_VkShaderModuleCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkShaderModuleCreateInfo_self(const VkShaderModuleCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_size_t(&val->codeSize); + if (val->pCode) { + size += vn_sizeof_array_size(val->codeSize / 4); + size += vn_sizeof_uint32_t_array(val->pCode, val->codeSize / 4); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkShaderModuleCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkShaderModuleCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkShaderModuleCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkShaderModuleCreateInfo_self(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_size_t(enc, &val->codeSize); + if (val->pCode) { + vn_encode_array_size(enc, val->codeSize / 4); + vn_encode_uint32_t_array(enc, val->pCode, val->codeSize / 4); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkShaderModuleCreateInfo(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO }); + vn_encode_VkShaderModuleCreateInfo_pnext(enc, val->pNext); + vn_encode_VkShaderModuleCreateInfo_self(enc, val); +} + +/* struct VkDescriptorSetLayoutBinding */ + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->binding); + size += vn_sizeof_VkDescriptorType(&val->descriptorType); + size += vn_sizeof_uint32_t(&val->descriptorCount); + size += vn_sizeof_VkFlags(&val->stageFlags); + if (val->pImmutableSamplers) { + size += vn_sizeof_array_size(val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + size += vn_sizeof_VkSampler(&val->pImmutableSamplers[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline void +vn_encode_VkDescriptorSetLayoutBinding(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBinding *val) +{ + vn_encode_uint32_t(enc, &val->binding); + vn_encode_VkDescriptorType(enc, &val->descriptorType); + vn_encode_uint32_t(enc, &val->descriptorCount); + vn_encode_VkFlags(enc, &val->stageFlags); + if (val->pImmutableSamplers) { + vn_encode_array_size(enc, val->descriptorCount); + for (uint32_t i = 0; i < val->descriptorCount; i++) + vn_encode_VkSampler(enc, &val->pImmutableSamplers[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +/* struct VkDescriptorSetLayoutBindingFlagsCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->bindingCount); + if (val->pBindingFlags) { + size += vn_sizeof_array_size(val->bindingCount); + for (uint32_t i = 0; i < val->bindingCount; i++) + size += vn_sizeof_VkFlags(&val->pBindingFlags[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->bindingCount); + if (val->pBindingFlags) { + vn_encode_array_size(enc, val->bindingCount); + for (uint32_t i = 0; i < val->bindingCount; i++) + vn_encode_VkFlags(enc, &val->pBindingFlags[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO }); + vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, val); +} + +/* struct VkDescriptorSetLayoutCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self((const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(const VkDescriptorSetLayoutCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->bindingCount); + if (val->pBindings) { + size += vn_sizeof_array_size(val->bindingCount); + for (uint32_t i = 0; i < val->bindingCount; i++) + size += vn_sizeof_VkDescriptorSetLayoutBinding(&val->pBindings[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, (const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorSetLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->bindingCount); + if (val->pBindings) { + vn_encode_array_size(enc, val->bindingCount); + for (uint32_t i = 0; i < val->bindingCount; i++) + vn_encode_VkDescriptorSetLayoutBinding(enc, &val->pBindings[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDescriptorSetLayoutCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }); + vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorSetLayoutCreateInfo_self(enc, val); +} + +/* struct VkDescriptorPoolSize */ + +static inline size_t +vn_sizeof_VkDescriptorPoolSize(const VkDescriptorPoolSize *val) +{ + size_t size = 0; + size += vn_sizeof_VkDescriptorType(&val->type); + size += vn_sizeof_uint32_t(&val->descriptorCount); + return size; +} + +static inline void +vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPoolSize *val) +{ + vn_encode_VkDescriptorType(enc, &val->type); + vn_encode_uint32_t(enc, &val->descriptorCount); +} + +/* struct VkDescriptorPoolCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorPoolCreateInfo_self(const VkDescriptorPoolCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->maxSets); + size += vn_sizeof_uint32_t(&val->poolSizeCount); + if (val->pPoolSizes) { + size += vn_sizeof_array_size(val->poolSizeCount); + for (uint32_t i = 0; i < val->poolSizeCount; i++) + size += vn_sizeof_VkDescriptorPoolSize(&val->pPoolSizes[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorPoolCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->maxSets); + vn_encode_uint32_t(enc, &val->poolSizeCount); + if (val->pPoolSizes) { + vn_encode_array_size(enc, val->poolSizeCount); + for (uint32_t i = 0; i < val->poolSizeCount; i++) + vn_encode_VkDescriptorPoolSize(enc, &val->pPoolSizes[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDescriptorPoolCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }); + vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorPoolCreateInfo_self(enc, val); +} + +/* struct VkDescriptorSetVariableDescriptorCountAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->descriptorSetCount); + if (val->pDescriptorCounts) { + size += vn_sizeof_array_size(val->descriptorSetCount); + size += vn_sizeof_uint32_t_array(val->pDescriptorCounts, val->descriptorSetCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->descriptorSetCount); + if (val->pDescriptorCounts) { + vn_encode_array_size(enc, val->descriptorSetCount); + vn_encode_uint32_t_array(enc, val->pDescriptorCounts, val->descriptorSetCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO }); + vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, val); +} + +/* struct VkDescriptorSetAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorSetAllocateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self((const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetAllocateInfo_self(const VkDescriptorSetAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDescriptorPool(&val->descriptorPool); + size += vn_sizeof_uint32_t(&val->descriptorSetCount); + if (val->pSetLayouts) { + size += vn_sizeof_array_size(val->descriptorSetCount); + for (uint32_t i = 0; i < val->descriptorSetCount; i++) + size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorSetAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorSetAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, pnext->pNext); + vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, (const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorSetAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDescriptorPool(enc, &val->descriptorPool); + vn_encode_uint32_t(enc, &val->descriptorSetCount); + if (val->pSetLayouts) { + vn_encode_array_size(enc, val->descriptorSetCount); + for (uint32_t i = 0; i < val->descriptorSetCount; i++) + vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDescriptorSetAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }); + vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorSetAllocateInfo_self(enc, val); +} + +/* struct VkSpecializationMapEntry */ + +static inline size_t +vn_sizeof_VkSpecializationMapEntry(const VkSpecializationMapEntry *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->constantID); + size += vn_sizeof_uint32_t(&val->offset); + size += vn_sizeof_size_t(&val->size); + return size; +} + +static inline void +vn_encode_VkSpecializationMapEntry(struct vn_cs_encoder *enc, const VkSpecializationMapEntry *val) +{ + vn_encode_uint32_t(enc, &val->constantID); + vn_encode_uint32_t(enc, &val->offset); + vn_encode_size_t(enc, &val->size); +} + +/* struct VkSpecializationInfo */ + +static inline size_t +vn_sizeof_VkSpecializationInfo(const VkSpecializationInfo *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->mapEntryCount); + if (val->pMapEntries) { + size += vn_sizeof_array_size(val->mapEntryCount); + for (uint32_t i = 0; i < val->mapEntryCount; i++) + size += vn_sizeof_VkSpecializationMapEntry(&val->pMapEntries[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_size_t(&val->dataSize); + if (val->pData) { + size += vn_sizeof_array_size(val->dataSize); + size += vn_sizeof_blob_array(val->pData, val->dataSize); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline void +vn_encode_VkSpecializationInfo(struct vn_cs_encoder *enc, const VkSpecializationInfo *val) +{ + vn_encode_uint32_t(enc, &val->mapEntryCount); + if (val->pMapEntries) { + vn_encode_array_size(enc, val->mapEntryCount); + for (uint32_t i = 0; i < val->mapEntryCount; i++) + vn_encode_VkSpecializationMapEntry(enc, &val->pMapEntries[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_size_t(enc, &val->dataSize); + if (val->pData) { + vn_encode_array_size(enc, val->dataSize); + vn_encode_blob_array(enc, val->pData, val->dataSize); + } else { + vn_encode_array_size(enc, 0); + } +} + +/* struct VkPipelineShaderStageCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkShaderStageFlagBits(&val->stage); + size += vn_sizeof_VkShaderModule(&val->module); + if (val->pName) { + const size_t string_size = strlen(val->pName) + 1; + size += vn_sizeof_array_size(string_size); + size += vn_sizeof_blob_array(val->pName, string_size); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_simple_pointer(val->pSpecializationInfo); + if (val->pSpecializationInfo) + size += vn_sizeof_VkSpecializationInfo(val->pSpecializationInfo); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineShaderStageCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkShaderStageFlagBits(enc, &val->stage); + vn_encode_VkShaderModule(enc, &val->module); + if (val->pName) { + const size_t string_size = strlen(val->pName) + 1; + vn_encode_array_size(enc, string_size); + vn_encode_blob_array(enc, val->pName, string_size); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, val->pSpecializationInfo)) + vn_encode_VkSpecializationInfo(enc, val->pSpecializationInfo); +} + +static inline void +vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO }); + vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineShaderStageCreateInfo_self(enc, val); +} + +/* struct VkComputePipelineCreateInfo chain */ + +static inline size_t +vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->stage); + size += vn_sizeof_VkPipelineLayout(&val->layout); + size += vn_sizeof_VkPipeline(&val->basePipelineHandle); + size += vn_sizeof_int32_t(&val->basePipelineIndex); + return size; +} + +static inline size_t +vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkComputePipelineCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkComputePipelineCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->stage); + vn_encode_VkPipelineLayout(enc, &val->layout); + vn_encode_VkPipeline(enc, &val->basePipelineHandle); + vn_encode_int32_t(enc, &val->basePipelineIndex); +} + +static inline void +vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO }); + vn_encode_VkComputePipelineCreateInfo_pnext(enc, val->pNext); + vn_encode_VkComputePipelineCreateInfo_self(enc, val); +} + +/* struct VkVertexInputBindingDescription */ + +static inline size_t +vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->binding); + size += vn_sizeof_uint32_t(&val->stride); + size += vn_sizeof_VkVertexInputRate(&val->inputRate); + return size; +} + +static inline void +vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder *enc, const VkVertexInputBindingDescription *val) +{ + vn_encode_uint32_t(enc, &val->binding); + vn_encode_uint32_t(enc, &val->stride); + vn_encode_VkVertexInputRate(enc, &val->inputRate); +} + +/* struct VkVertexInputAttributeDescription */ + +static inline size_t +vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->location); + size += vn_sizeof_uint32_t(&val->binding); + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_uint32_t(&val->offset); + return size; +} + +static inline void +vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder *enc, const VkVertexInputAttributeDescription *val) +{ + vn_encode_uint32_t(enc, &val->location); + vn_encode_uint32_t(enc, &val->binding); + vn_encode_VkFormat(enc, &val->format); + vn_encode_uint32_t(enc, &val->offset); +} + +/* struct VkPipelineVertexInputStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->vertexBindingDescriptionCount); + if (val->pVertexBindingDescriptions) { + size += vn_sizeof_array_size(val->vertexBindingDescriptionCount); + for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++) + size += vn_sizeof_VkVertexInputBindingDescription(&val->pVertexBindingDescriptions[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->vertexAttributeDescriptionCount); + if (val->pVertexAttributeDescriptions) { + size += vn_sizeof_array_size(val->vertexAttributeDescriptionCount); + for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++) + size += vn_sizeof_VkVertexInputAttributeDescription(&val->pVertexAttributeDescriptions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->vertexBindingDescriptionCount); + if (val->pVertexBindingDescriptions) { + vn_encode_array_size(enc, val->vertexBindingDescriptionCount); + for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++) + vn_encode_VkVertexInputBindingDescription(enc, &val->pVertexBindingDescriptions[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->vertexAttributeDescriptionCount); + if (val->pVertexAttributeDescriptions) { + vn_encode_array_size(enc, val->vertexAttributeDescriptionCount); + for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++) + vn_encode_VkVertexInputAttributeDescription(enc, &val->pVertexAttributeDescriptions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO }); + vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineVertexInputStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineInputAssemblyStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkPrimitiveTopology(&val->topology); + size += vn_sizeof_VkBool32(&val->primitiveRestartEnable); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkPrimitiveTopology(enc, &val->topology); + vn_encode_VkBool32(enc, &val->primitiveRestartEnable); +} + +static inline void +vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }); + vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkTessellationDomainOrigin(&val->domainOrigin); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkTessellationDomainOrigin(enc, &val->domainOrigin); +} + +static inline void +vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO }); + vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineTessellationStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self((const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->patchControlPoints); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineTessellationStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, (const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->patchControlPoints); +} + +static inline void +vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO }); + vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineTessellationStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineViewportStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->viewportCount); + if (val->pViewports) { + size += vn_sizeof_array_size(val->viewportCount); + for (uint32_t i = 0; i < val->viewportCount; i++) + size += vn_sizeof_VkViewport(&val->pViewports[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->scissorCount); + if (val->pScissors) { + size += vn_sizeof_array_size(val->scissorCount); + for (uint32_t i = 0; i < val->scissorCount; i++) + size += vn_sizeof_VkRect2D(&val->pScissors[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineViewportStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->viewportCount); + if (val->pViewports) { + vn_encode_array_size(enc, val->viewportCount); + for (uint32_t i = 0; i < val->viewportCount; i++) + vn_encode_VkViewport(enc, &val->pViewports[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->scissorCount); + if (val->pScissors) { + vn_encode_array_size(enc, val->scissorCount); + for (uint32_t i = 0; i < val->scissorCount; i++) + vn_encode_VkRect2D(enc, &val->pScissors[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }); + vn_encode_VkPipelineViewportStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineViewportStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */ + +static inline size_t +vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->rasterizationStream); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(val->pNext); + size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->rasterizationStream); +} + +static inline void +vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT }); + vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(enc, val->pNext); + vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, val); +} + +/* struct VkPipelineRasterizationStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self((const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkBool32(&val->depthClampEnable); + size += vn_sizeof_VkBool32(&val->rasterizerDiscardEnable); + size += vn_sizeof_VkPolygonMode(&val->polygonMode); + size += vn_sizeof_VkFlags(&val->cullMode); + size += vn_sizeof_VkFrontFace(&val->frontFace); + size += vn_sizeof_VkBool32(&val->depthBiasEnable); + size += vn_sizeof_float(&val->depthBiasConstantFactor); + size += vn_sizeof_float(&val->depthBiasClamp); + size += vn_sizeof_float(&val->depthBiasSlopeFactor); + size += vn_sizeof_float(&val->lineWidth); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, (const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkBool32(enc, &val->depthClampEnable); + vn_encode_VkBool32(enc, &val->rasterizerDiscardEnable); + vn_encode_VkPolygonMode(enc, &val->polygonMode); + vn_encode_VkFlags(enc, &val->cullMode); + vn_encode_VkFrontFace(enc, &val->frontFace); + vn_encode_VkBool32(enc, &val->depthBiasEnable); + vn_encode_float(enc, &val->depthBiasConstantFactor); + vn_encode_float(enc, &val->depthBiasClamp); + vn_encode_float(enc, &val->depthBiasSlopeFactor); + vn_encode_float(enc, &val->lineWidth); +} + +static inline void +vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }); + vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineRasterizationStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineMultisampleStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkSampleCountFlagBits(&val->rasterizationSamples); + size += vn_sizeof_VkBool32(&val->sampleShadingEnable); + size += vn_sizeof_float(&val->minSampleShading); + if (val->pSampleMask) { + size += vn_sizeof_array_size((val->rasterizationSamples + 31) / 32); + size += vn_sizeof_VkSampleMask_array(val->pSampleMask, (val->rasterizationSamples + 31) / 32); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_VkBool32(&val->alphaToCoverageEnable); + size += vn_sizeof_VkBool32(&val->alphaToOneEnable); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkSampleCountFlagBits(enc, &val->rasterizationSamples); + vn_encode_VkBool32(enc, &val->sampleShadingEnable); + vn_encode_float(enc, &val->minSampleShading); + if (val->pSampleMask) { + vn_encode_array_size(enc, (val->rasterizationSamples + 31) / 32); + vn_encode_VkSampleMask_array(enc, val->pSampleMask, (val->rasterizationSamples + 31) / 32); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkBool32(enc, &val->alphaToCoverageEnable); + vn_encode_VkBool32(enc, &val->alphaToOneEnable); +} + +static inline void +vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }); + vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineMultisampleStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineColorBlendAttachmentState */ + +static inline size_t +vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState *val) +{ + size_t size = 0; + size += vn_sizeof_VkBool32(&val->blendEnable); + size += vn_sizeof_VkBlendFactor(&val->srcColorBlendFactor); + size += vn_sizeof_VkBlendFactor(&val->dstColorBlendFactor); + size += vn_sizeof_VkBlendOp(&val->colorBlendOp); + size += vn_sizeof_VkBlendFactor(&val->srcAlphaBlendFactor); + size += vn_sizeof_VkBlendFactor(&val->dstAlphaBlendFactor); + size += vn_sizeof_VkBlendOp(&val->alphaBlendOp); + size += vn_sizeof_VkFlags(&val->colorWriteMask); + return size; +} + +static inline void +vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder *enc, const VkPipelineColorBlendAttachmentState *val) +{ + vn_encode_VkBool32(enc, &val->blendEnable); + vn_encode_VkBlendFactor(enc, &val->srcColorBlendFactor); + vn_encode_VkBlendFactor(enc, &val->dstColorBlendFactor); + vn_encode_VkBlendOp(enc, &val->colorBlendOp); + vn_encode_VkBlendFactor(enc, &val->srcAlphaBlendFactor); + vn_encode_VkBlendFactor(enc, &val->dstAlphaBlendFactor); + vn_encode_VkBlendOp(enc, &val->alphaBlendOp); + vn_encode_VkFlags(enc, &val->colorWriteMask); +} + +/* struct VkPipelineColorBlendStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkBool32(&val->logicOpEnable); + size += vn_sizeof_VkLogicOp(&val->logicOp); + size += vn_sizeof_uint32_t(&val->attachmentCount); + if (val->pAttachments) { + size += vn_sizeof_array_size(val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + size += vn_sizeof_VkPipelineColorBlendAttachmentState(&val->pAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_array_size(4); + size += vn_sizeof_float_array(val->blendConstants, 4); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkBool32(enc, &val->logicOpEnable); + vn_encode_VkLogicOp(enc, &val->logicOp); + vn_encode_uint32_t(enc, &val->attachmentCount); + if (val->pAttachments) { + vn_encode_array_size(enc, val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + vn_encode_VkPipelineColorBlendAttachmentState(enc, &val->pAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_array_size(enc, 4); + vn_encode_float_array(enc, val->blendConstants, 4); +} + +static inline void +vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }); + vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineColorBlendStateCreateInfo_self(enc, val); +} + +/* struct VkPipelineDynamicStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->dynamicStateCount); + if (val->pDynamicStates) { + size += vn_sizeof_array_size(val->dynamicStateCount); + size += vn_sizeof_VkDynamicState_array(val->pDynamicStates, val->dynamicStateCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineDynamicStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->dynamicStateCount); + if (val->pDynamicStates) { + vn_encode_array_size(enc, val->dynamicStateCount); + vn_encode_VkDynamicState_array(enc, val->pDynamicStates, val->dynamicStateCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }); + vn_encode_VkPipelineDynamicStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val); +} + +/* struct VkStencilOpState */ + +static inline size_t +vn_sizeof_VkStencilOpState(const VkStencilOpState *val) +{ + size_t size = 0; + size += vn_sizeof_VkStencilOp(&val->failOp); + size += vn_sizeof_VkStencilOp(&val->passOp); + size += vn_sizeof_VkStencilOp(&val->depthFailOp); + size += vn_sizeof_VkCompareOp(&val->compareOp); + size += vn_sizeof_uint32_t(&val->compareMask); + size += vn_sizeof_uint32_t(&val->writeMask); + size += vn_sizeof_uint32_t(&val->reference); + return size; +} + +static inline void +vn_encode_VkStencilOpState(struct vn_cs_encoder *enc, const VkStencilOpState *val) +{ + vn_encode_VkStencilOp(enc, &val->failOp); + vn_encode_VkStencilOp(enc, &val->passOp); + vn_encode_VkStencilOp(enc, &val->depthFailOp); + vn_encode_VkCompareOp(enc, &val->compareOp); + vn_encode_uint32_t(enc, &val->compareMask); + vn_encode_uint32_t(enc, &val->writeMask); + vn_encode_uint32_t(enc, &val->reference); +} + +/* struct VkPipelineDepthStencilStateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkBool32(&val->depthTestEnable); + size += vn_sizeof_VkBool32(&val->depthWriteEnable); + size += vn_sizeof_VkCompareOp(&val->depthCompareOp); + size += vn_sizeof_VkBool32(&val->depthBoundsTestEnable); + size += vn_sizeof_VkBool32(&val->stencilTestEnable); + size += vn_sizeof_VkStencilOpState(&val->front); + size += vn_sizeof_VkStencilOpState(&val->back); + size += vn_sizeof_float(&val->minDepthBounds); + size += vn_sizeof_float(&val->maxDepthBounds); + return size; +} + +static inline size_t +vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkBool32(enc, &val->depthTestEnable); + vn_encode_VkBool32(enc, &val->depthWriteEnable); + vn_encode_VkCompareOp(enc, &val->depthCompareOp); + vn_encode_VkBool32(enc, &val->depthBoundsTestEnable); + vn_encode_VkBool32(enc, &val->stencilTestEnable); + vn_encode_VkStencilOpState(enc, &val->front); + vn_encode_VkStencilOpState(enc, &val->back); + vn_encode_float(enc, &val->minDepthBounds); + vn_encode_float(enc, &val->maxDepthBounds); +} + +static inline void +vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO }); + vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineDepthStencilStateCreateInfo_self(enc, val); +} + +/* struct VkGraphicsPipelineCreateInfo chain */ + +static inline size_t +vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->stageCount); + if (val->pStages) { + size += vn_sizeof_array_size(val->stageCount); + for (uint32_t i = 0; i < val->stageCount; i++) + size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->pStages[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_simple_pointer(val->pVertexInputState); + if (val->pVertexInputState) + size += vn_sizeof_VkPipelineVertexInputStateCreateInfo(val->pVertexInputState); + size += vn_sizeof_simple_pointer(val->pInputAssemblyState); + if (val->pInputAssemblyState) + size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(val->pInputAssemblyState); + size += vn_sizeof_simple_pointer(val->pTessellationState); + if (val->pTessellationState) + size += vn_sizeof_VkPipelineTessellationStateCreateInfo(val->pTessellationState); + size += vn_sizeof_simple_pointer(val->pViewportState); + if (val->pViewportState) + size += vn_sizeof_VkPipelineViewportStateCreateInfo(val->pViewportState); + size += vn_sizeof_simple_pointer(val->pRasterizationState); + if (val->pRasterizationState) + size += vn_sizeof_VkPipelineRasterizationStateCreateInfo(val->pRasterizationState); + size += vn_sizeof_simple_pointer(val->pMultisampleState); + if (val->pMultisampleState) + size += vn_sizeof_VkPipelineMultisampleStateCreateInfo(val->pMultisampleState); + size += vn_sizeof_simple_pointer(val->pDepthStencilState); + if (val->pDepthStencilState) + size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo(val->pDepthStencilState); + size += vn_sizeof_simple_pointer(val->pColorBlendState); + if (val->pColorBlendState) + size += vn_sizeof_VkPipelineColorBlendStateCreateInfo(val->pColorBlendState); + size += vn_sizeof_simple_pointer(val->pDynamicState); + if (val->pDynamicState) + size += vn_sizeof_VkPipelineDynamicStateCreateInfo(val->pDynamicState); + size += vn_sizeof_VkPipelineLayout(&val->layout); + size += vn_sizeof_VkRenderPass(&val->renderPass); + size += vn_sizeof_uint32_t(&val->subpass); + size += vn_sizeof_VkPipeline(&val->basePipelineHandle); + size += vn_sizeof_int32_t(&val->basePipelineIndex); + return size; +} + +static inline size_t +vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkGraphicsPipelineCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->stageCount); + if (val->pStages) { + vn_encode_array_size(enc, val->stageCount); + for (uint32_t i = 0; i < val->stageCount; i++) + vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->pStages[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, val->pVertexInputState)) + vn_encode_VkPipelineVertexInputStateCreateInfo(enc, val->pVertexInputState); + if (vn_encode_simple_pointer(enc, val->pInputAssemblyState)) + vn_encode_VkPipelineInputAssemblyStateCreateInfo(enc, val->pInputAssemblyState); + if (vn_encode_simple_pointer(enc, val->pTessellationState)) + vn_encode_VkPipelineTessellationStateCreateInfo(enc, val->pTessellationState); + if (vn_encode_simple_pointer(enc, val->pViewportState)) + vn_encode_VkPipelineViewportStateCreateInfo(enc, val->pViewportState); + if (vn_encode_simple_pointer(enc, val->pRasterizationState)) + vn_encode_VkPipelineRasterizationStateCreateInfo(enc, val->pRasterizationState); + if (vn_encode_simple_pointer(enc, val->pMultisampleState)) + vn_encode_VkPipelineMultisampleStateCreateInfo(enc, val->pMultisampleState); + if (vn_encode_simple_pointer(enc, val->pDepthStencilState)) + vn_encode_VkPipelineDepthStencilStateCreateInfo(enc, val->pDepthStencilState); + if (vn_encode_simple_pointer(enc, val->pColorBlendState)) + vn_encode_VkPipelineColorBlendStateCreateInfo(enc, val->pColorBlendState); + if (vn_encode_simple_pointer(enc, val->pDynamicState)) + vn_encode_VkPipelineDynamicStateCreateInfo(enc, val->pDynamicState); + vn_encode_VkPipelineLayout(enc, &val->layout); + vn_encode_VkRenderPass(enc, &val->renderPass); + vn_encode_uint32_t(enc, &val->subpass); + vn_encode_VkPipeline(enc, &val->basePipelineHandle); + vn_encode_int32_t(enc, &val->basePipelineIndex); +} + +static inline void +vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO }); + vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, val->pNext); + vn_encode_VkGraphicsPipelineCreateInfo_self(enc, val); +} + +/* struct VkPipelineCacheCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineCacheCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineCacheCreateInfo_self(const VkPipelineCacheCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_size_t(&val->initialDataSize); + if (val->pInitialData) { + size += vn_sizeof_array_size(val->initialDataSize); + size += vn_sizeof_blob_array(val->pInitialData, val->initialDataSize); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineCacheCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineCacheCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineCacheCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineCacheCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_size_t(enc, &val->initialDataSize); + if (val->pInitialData) { + vn_encode_array_size(enc, val->initialDataSize); + vn_encode_blob_array(enc, val->pInitialData, val->initialDataSize); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPipelineCacheCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO }); + vn_encode_VkPipelineCacheCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineCacheCreateInfo_self(enc, val); +} + +/* struct VkPushConstantRange */ + +static inline size_t +vn_sizeof_VkPushConstantRange(const VkPushConstantRange *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->stageFlags); + size += vn_sizeof_uint32_t(&val->offset); + size += vn_sizeof_uint32_t(&val->size); + return size; +} + +static inline void +vn_encode_VkPushConstantRange(struct vn_cs_encoder *enc, const VkPushConstantRange *val) +{ + vn_encode_VkFlags(enc, &val->stageFlags); + vn_encode_uint32_t(enc, &val->offset); + vn_encode_uint32_t(enc, &val->size); +} + +/* struct VkPipelineLayoutCreateInfo chain */ + +static inline size_t +vn_sizeof_VkPipelineLayoutCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPipelineLayoutCreateInfo_self(const VkPipelineLayoutCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->setLayoutCount); + if (val->pSetLayouts) { + size += vn_sizeof_array_size(val->setLayoutCount); + for (uint32_t i = 0; i < val->setLayoutCount; i++) + size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->pushConstantRangeCount); + if (val->pPushConstantRanges) { + size += vn_sizeof_array_size(val->pushConstantRangeCount); + for (uint32_t i = 0; i < val->pushConstantRangeCount; i++) + size += vn_sizeof_VkPushConstantRange(&val->pPushConstantRanges[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPipelineLayoutCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkPipelineLayoutCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPipelineLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPipelineLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->setLayoutCount); + if (val->pSetLayouts) { + vn_encode_array_size(enc, val->setLayoutCount); + for (uint32_t i = 0; i < val->setLayoutCount; i++) + vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->pushConstantRangeCount); + if (val->pPushConstantRanges) { + vn_encode_array_size(enc, val->pushConstantRangeCount); + for (uint32_t i = 0; i < val->pushConstantRangeCount; i++) + vn_encode_VkPushConstantRange(enc, &val->pPushConstantRanges[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPipelineLayoutCreateInfo(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }); + vn_encode_VkPipelineLayoutCreateInfo_pnext(enc, val->pNext); + vn_encode_VkPipelineLayoutCreateInfo_self(enc, val); +} + +/* struct VkSamplerReductionModeCreateInfo chain */ + +static inline size_t +vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSamplerReductionModeCreateInfo_self(const VkSamplerReductionModeCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSamplerReductionMode(&val->reductionMode); + return size; +} + +static inline size_t +vn_sizeof_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkSamplerReductionModeCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSamplerReductionModeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSamplerReductionModeCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSamplerReductionMode(enc, &val->reductionMode); +} + +static inline void +vn_encode_VkSamplerReductionModeCreateInfo(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO }); + vn_encode_VkSamplerReductionModeCreateInfo_pnext(enc, val->pNext); + vn_encode_VkSamplerReductionModeCreateInfo_self(enc, val); +} + +/* struct VkSamplerCreateInfo chain */ + +static inline size_t +vn_sizeof_VkSamplerCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkSamplerReductionModeCreateInfo_self((const VkSamplerReductionModeCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSamplerCreateInfo_self(const VkSamplerCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkFilter(&val->magFilter); + size += vn_sizeof_VkFilter(&val->minFilter); + size += vn_sizeof_VkSamplerMipmapMode(&val->mipmapMode); + size += vn_sizeof_VkSamplerAddressMode(&val->addressModeU); + size += vn_sizeof_VkSamplerAddressMode(&val->addressModeV); + size += vn_sizeof_VkSamplerAddressMode(&val->addressModeW); + size += vn_sizeof_float(&val->mipLodBias); + size += vn_sizeof_VkBool32(&val->anisotropyEnable); + size += vn_sizeof_float(&val->maxAnisotropy); + size += vn_sizeof_VkBool32(&val->compareEnable); + size += vn_sizeof_VkCompareOp(&val->compareOp); + size += vn_sizeof_float(&val->minLod); + size += vn_sizeof_float(&val->maxLod); + size += vn_sizeof_VkBorderColor(&val->borderColor); + size += vn_sizeof_VkBool32(&val->unnormalizedCoordinates); + return size; +} + +static inline size_t +vn_sizeof_VkSamplerCreateInfo(const VkSamplerCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSamplerCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkSamplerCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSamplerCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkSamplerReductionModeCreateInfo_self(enc, (const VkSamplerReductionModeCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSamplerCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkFilter(enc, &val->magFilter); + vn_encode_VkFilter(enc, &val->minFilter); + vn_encode_VkSamplerMipmapMode(enc, &val->mipmapMode); + vn_encode_VkSamplerAddressMode(enc, &val->addressModeU); + vn_encode_VkSamplerAddressMode(enc, &val->addressModeV); + vn_encode_VkSamplerAddressMode(enc, &val->addressModeW); + vn_encode_float(enc, &val->mipLodBias); + vn_encode_VkBool32(enc, &val->anisotropyEnable); + vn_encode_float(enc, &val->maxAnisotropy); + vn_encode_VkBool32(enc, &val->compareEnable); + vn_encode_VkCompareOp(enc, &val->compareOp); + vn_encode_float(enc, &val->minLod); + vn_encode_float(enc, &val->maxLod); + vn_encode_VkBorderColor(enc, &val->borderColor); + vn_encode_VkBool32(enc, &val->unnormalizedCoordinates); +} + +static inline void +vn_encode_VkSamplerCreateInfo(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO }); + vn_encode_VkSamplerCreateInfo_pnext(enc, val->pNext); + vn_encode_VkSamplerCreateInfo_self(enc, val); +} + +/* struct VkCommandPoolCreateInfo chain */ + +static inline size_t +vn_sizeof_VkCommandPoolCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCommandPoolCreateInfo_self(const VkCommandPoolCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->queueFamilyIndex); + return size; +} + +static inline size_t +vn_sizeof_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCommandPoolCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkCommandPoolCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkCommandPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCommandPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->queueFamilyIndex); +} + +static inline void +vn_encode_VkCommandPoolCreateInfo(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO }); + vn_encode_VkCommandPoolCreateInfo_pnext(enc, val->pNext); + vn_encode_VkCommandPoolCreateInfo_self(enc, val); +} + +/* struct VkCommandBufferAllocateInfo chain */ + +static inline size_t +vn_sizeof_VkCommandBufferAllocateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCommandBufferAllocateInfo_self(const VkCommandBufferAllocateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkCommandPool(&val->commandPool); + size += vn_sizeof_VkCommandBufferLevel(&val->level); + size += vn_sizeof_uint32_t(&val->commandBufferCount); + return size; +} + +static inline size_t +vn_sizeof_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCommandBufferAllocateInfo_pnext(val->pNext); + size += vn_sizeof_VkCommandBufferAllocateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkCommandBufferAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkCommandBufferAllocateInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferAllocateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkCommandPool(enc, &val->commandPool); + vn_encode_VkCommandBufferLevel(enc, &val->level); + vn_encode_uint32_t(enc, &val->commandBufferCount); +} + +static inline void +vn_encode_VkCommandBufferAllocateInfo(struct vn_cs_encoder *enc, const VkCommandBufferAllocateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO }); + vn_encode_VkCommandBufferAllocateInfo_pnext(enc, val->pNext); + vn_encode_VkCommandBufferAllocateInfo_self(enc, val); +} + +/* struct VkCommandBufferInheritanceInfo chain */ + +static inline size_t +vn_sizeof_VkCommandBufferInheritanceInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCommandBufferInheritanceInfo_self(const VkCommandBufferInheritanceInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkRenderPass(&val->renderPass); + size += vn_sizeof_uint32_t(&val->subpass); + size += vn_sizeof_VkFramebuffer(&val->framebuffer); + size += vn_sizeof_VkBool32(&val->occlusionQueryEnable); + size += vn_sizeof_VkFlags(&val->queryFlags); + size += vn_sizeof_VkFlags(&val->pipelineStatistics); + return size; +} + +static inline size_t +vn_sizeof_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCommandBufferInheritanceInfo_pnext(val->pNext); + size += vn_sizeof_VkCommandBufferInheritanceInfo_self(val); + + return size; +} + +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(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkCommandBufferInheritanceInfo_self(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkRenderPass(dec, &val->renderPass); + vn_decode_uint32_t(dec, &val->subpass); + vn_decode_VkFramebuffer(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(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO); + + assert(val->sType == stype); + vn_decode_VkCommandBufferInheritanceInfo_pnext(dec, val->pNext); + vn_decode_VkCommandBufferInheritanceInfo_self(dec, val); +} + +/* struct VkDeviceGroupCommandBufferBeginInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self(const VkDeviceGroupCommandBufferBeginInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->deviceMask); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self(val); + + return size; +} + +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(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->deviceMask); +} + +static inline void +vn_decode_VkDeviceGroupCommandBufferBeginInfo(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO); + + assert(val->sType == stype); + vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext(dec, val->pNext); + vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(dec, val); +} + +/* struct VkCommandBufferBeginInfo chain */ + +static inline size_t +vn_sizeof_VkCommandBufferBeginInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkCommandBufferBeginInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDeviceGroupCommandBufferBeginInfo_self((const VkDeviceGroupCommandBufferBeginInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkCommandBufferBeginInfo_self(const VkCommandBufferBeginInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_simple_pointer(val->pInheritanceInfo); + if (val->pInheritanceInfo) + size += vn_sizeof_VkCommandBufferInheritanceInfo(val->pInheritanceInfo); + return size; +} + +static inline size_t +vn_sizeof_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkCommandBufferBeginInfo_pnext(val->pNext); + size += vn_sizeof_VkCommandBufferBeginInfo_self(val); + + return size; +} + +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(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + vn_decode_VkCommandBufferBeginInfo_pnext(dec, pnext->pNext); + vn_decode_VkDeviceGroupCommandBufferBeginInfo_self(dec, (VkDeviceGroupCommandBufferBeginInfo *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkCommandBufferBeginInfo_self(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->flags); + if (vn_decode_simple_pointer(dec)) { + vn_decode_VkCommandBufferInheritanceInfo(dec, (VkCommandBufferInheritanceInfo *)val->pInheritanceInfo); + } else { + val->pInheritanceInfo = NULL; + } +} + +static inline void +vn_decode_VkCommandBufferBeginInfo(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO); + + assert(val->sType == stype); + vn_decode_VkCommandBufferBeginInfo_pnext(dec, val->pNext); + vn_decode_VkCommandBufferBeginInfo_self(dec, val); +} + +/* union VkClearColorValue */ + +static inline size_t +vn_sizeof_VkClearColorValue_tag(const VkClearColorValue *val, uint32_t tag) +{ + size_t size = vn_sizeof_uint32_t(&tag); + switch (tag) { + case 0: + size += vn_sizeof_array_size(4); + size += vn_sizeof_float_array(val->float32, 4); + break; + case 1: + size += vn_sizeof_array_size(4); + size += vn_sizeof_int32_t_array(val->int32, 4); + break; + case 2: + size += vn_sizeof_array_size(4); + size += vn_sizeof_uint32_t_array(val->uint32, 4); + break; + default: + assert(false); + break; + } + return size; +} + +static inline size_t +vn_sizeof_VkClearColorValue(const VkClearColorValue *val) +{ + return vn_sizeof_VkClearColorValue_tag(val, 2); +} + +static inline void +vn_encode_VkClearColorValue_tag(struct vn_cs_encoder *enc, const VkClearColorValue *val, uint32_t tag) +{ + vn_encode_uint32_t(enc, &tag); + switch (tag) { + case 0: + vn_encode_array_size(enc, 4); + vn_encode_float_array(enc, val->float32, 4); + break; + case 1: + vn_encode_array_size(enc, 4); + vn_encode_int32_t_array(enc, val->int32, 4); + break; + case 2: + vn_encode_array_size(enc, 4); + vn_encode_uint32_t_array(enc, val->uint32, 4); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_encode_VkClearColorValue(struct vn_cs_encoder *enc, const VkClearColorValue *val) +{ + vn_encode_VkClearColorValue_tag(enc, val, 2); /* union with default tag */ +} + +/* struct VkClearDepthStencilValue */ + +static inline size_t +vn_sizeof_VkClearDepthStencilValue(const VkClearDepthStencilValue *val) +{ + size_t size = 0; + size += vn_sizeof_float(&val->depth); + size += vn_sizeof_uint32_t(&val->stencil); + return size; +} + +static inline void +vn_encode_VkClearDepthStencilValue(struct vn_cs_encoder *enc, const VkClearDepthStencilValue *val) +{ + vn_encode_float(enc, &val->depth); + vn_encode_uint32_t(enc, &val->stencil); +} + +/* union VkClearValue */ + +static inline size_t +vn_sizeof_VkClearValue_tag(const VkClearValue *val, uint32_t tag) +{ + size_t size = vn_sizeof_uint32_t(&tag); + switch (tag) { + case 0: + size += vn_sizeof_VkClearColorValue(&val->color); + break; + case 1: + size += vn_sizeof_VkClearDepthStencilValue(&val->depthStencil); + break; + default: + assert(false); + break; + } + return size; +} + +static inline size_t +vn_sizeof_VkClearValue(const VkClearValue *val) +{ + return vn_sizeof_VkClearValue_tag(val, 0); +} + +static inline void +vn_encode_VkClearValue_tag(struct vn_cs_encoder *enc, const VkClearValue *val, uint32_t tag) +{ + vn_encode_uint32_t(enc, &tag); + switch (tag) { + case 0: + vn_encode_VkClearColorValue(enc, &val->color); + break; + case 1: + vn_encode_VkClearDepthStencilValue(enc, &val->depthStencil); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_encode_VkClearValue(struct vn_cs_encoder *enc, const VkClearValue *val) +{ + vn_encode_VkClearValue_tag(enc, val, 0); /* union with default tag */ +} + +/* struct VkDeviceGroupRenderPassBeginInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceGroupRenderPassBeginInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self(const VkDeviceGroupRenderPassBeginInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->deviceMask); + size += vn_sizeof_uint32_t(&val->deviceRenderAreaCount); + if (val->pDeviceRenderAreas) { + size += vn_sizeof_array_size(val->deviceRenderAreaCount); + for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++) + size += vn_sizeof_VkRect2D(&val->pDeviceRenderAreas[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceGroupRenderPassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceGroupRenderPassBeginInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupRenderPassBeginInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->deviceMask); + vn_encode_uint32_t(enc, &val->deviceRenderAreaCount); + if (val->pDeviceRenderAreas) { + vn_encode_array_size(enc, val->deviceRenderAreaCount); + for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++) + vn_encode_VkRect2D(enc, &val->pDeviceRenderAreas[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDeviceGroupRenderPassBeginInfo(struct vn_cs_encoder *enc, const VkDeviceGroupRenderPassBeginInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO }); + vn_encode_VkDeviceGroupRenderPassBeginInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, val); +} + +/* struct VkRenderPassAttachmentBeginInfo chain */ + +static inline size_t +vn_sizeof_VkRenderPassAttachmentBeginInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderPassAttachmentBeginInfo_self(const VkRenderPassAttachmentBeginInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->attachmentCount); + if (val->pAttachments) { + size += vn_sizeof_array_size(val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + size += vn_sizeof_VkImageView(&val->pAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderPassAttachmentBeginInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderPassAttachmentBeginInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderPassAttachmentBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderPassAttachmentBeginInfo_self(struct vn_cs_encoder *enc, const VkRenderPassAttachmentBeginInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->attachmentCount); + if (val->pAttachments) { + vn_encode_array_size(enc, val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + vn_encode_VkImageView(enc, &val->pAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkRenderPassAttachmentBeginInfo(struct vn_cs_encoder *enc, const VkRenderPassAttachmentBeginInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO }); + vn_encode_VkRenderPassAttachmentBeginInfo_pnext(enc, val->pNext); + vn_encode_VkRenderPassAttachmentBeginInfo_self(enc, val); +} + +/* struct VkRenderPassBeginInfo chain */ + +static inline size_t +vn_sizeof_VkRenderPassBeginInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkRenderPassBeginInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDeviceGroupRenderPassBeginInfo_self((const VkDeviceGroupRenderPassBeginInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkRenderPassBeginInfo_pnext(pnext->pNext); + size += vn_sizeof_VkRenderPassAttachmentBeginInfo_self((const VkRenderPassAttachmentBeginInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderPassBeginInfo_self(const VkRenderPassBeginInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkRenderPass(&val->renderPass); + size += vn_sizeof_VkFramebuffer(&val->framebuffer); + size += vn_sizeof_VkRect2D(&val->renderArea); + size += vn_sizeof_uint32_t(&val->clearValueCount); + if (val->pClearValues) { + size += vn_sizeof_array_size(val->clearValueCount); + for (uint32_t i = 0; i < val->clearValueCount; i++) + size += vn_sizeof_VkClearValue(&val->pClearValues[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkRenderPassBeginInfo(const VkRenderPassBeginInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderPassBeginInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderPassBeginInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderPassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkRenderPassBeginInfo_pnext(enc, pnext->pNext); + vn_encode_VkDeviceGroupRenderPassBeginInfo_self(enc, (const VkDeviceGroupRenderPassBeginInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkRenderPassBeginInfo_pnext(enc, pnext->pNext); + vn_encode_VkRenderPassAttachmentBeginInfo_self(enc, (const VkRenderPassAttachmentBeginInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderPassBeginInfo_self(struct vn_cs_encoder *enc, const VkRenderPassBeginInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkRenderPass(enc, &val->renderPass); + vn_encode_VkFramebuffer(enc, &val->framebuffer); + vn_encode_VkRect2D(enc, &val->renderArea); + vn_encode_uint32_t(enc, &val->clearValueCount); + if (val->pClearValues) { + vn_encode_array_size(enc, val->clearValueCount); + for (uint32_t i = 0; i < val->clearValueCount; i++) + vn_encode_VkClearValue(enc, &val->pClearValues[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkRenderPassBeginInfo(struct vn_cs_encoder *enc, const VkRenderPassBeginInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO }); + vn_encode_VkRenderPassBeginInfo_pnext(enc, val->pNext); + vn_encode_VkRenderPassBeginInfo_self(enc, val); +} + +/* struct VkClearAttachment */ + +static inline size_t +vn_sizeof_VkClearAttachment(const VkClearAttachment *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->aspectMask); + size += vn_sizeof_uint32_t(&val->colorAttachment); + size += vn_sizeof_VkClearValue(&val->clearValue); + return size; +} + +static inline void +vn_encode_VkClearAttachment(struct vn_cs_encoder *enc, const VkClearAttachment *val) +{ + vn_encode_VkFlags(enc, &val->aspectMask); + vn_encode_uint32_t(enc, &val->colorAttachment); + vn_encode_VkClearValue(enc, &val->clearValue); +} + +/* struct VkAttachmentDescription */ + +static inline size_t +vn_sizeof_VkAttachmentDescription(const VkAttachmentDescription *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkSampleCountFlagBits(&val->samples); + size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp); + size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp); + size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp); + size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp); + size += vn_sizeof_VkImageLayout(&val->initialLayout); + size += vn_sizeof_VkImageLayout(&val->finalLayout); + return size; +} + +static inline void +vn_encode_VkAttachmentDescription(struct vn_cs_encoder *enc, const VkAttachmentDescription *val) +{ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkSampleCountFlagBits(enc, &val->samples); + vn_encode_VkAttachmentLoadOp(enc, &val->loadOp); + vn_encode_VkAttachmentStoreOp(enc, &val->storeOp); + vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp); + vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp); + vn_encode_VkImageLayout(enc, &val->initialLayout); + vn_encode_VkImageLayout(enc, &val->finalLayout); +} + +/* struct VkAttachmentReference */ + +static inline size_t +vn_sizeof_VkAttachmentReference(const VkAttachmentReference *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->attachment); + size += vn_sizeof_VkImageLayout(&val->layout); + return size; +} + +static inline void +vn_encode_VkAttachmentReference(struct vn_cs_encoder *enc, const VkAttachmentReference *val) +{ + vn_encode_uint32_t(enc, &val->attachment); + vn_encode_VkImageLayout(enc, &val->layout); +} + +/* struct VkSubpassDescription */ + +static inline size_t +vn_sizeof_VkSubpassDescription(const VkSubpassDescription *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint); + size += vn_sizeof_uint32_t(&val->inputAttachmentCount); + if (val->pInputAttachments) { + size += vn_sizeof_array_size(val->inputAttachmentCount); + for (uint32_t i = 0; i < val->inputAttachmentCount; i++) + size += vn_sizeof_VkAttachmentReference(&val->pInputAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->colorAttachmentCount); + if (val->pColorAttachments) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + size += vn_sizeof_VkAttachmentReference(&val->pColorAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + if (val->pResolveAttachments) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + size += vn_sizeof_VkAttachmentReference(&val->pResolveAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment); + if (val->pDepthStencilAttachment) + size += vn_sizeof_VkAttachmentReference(val->pDepthStencilAttachment); + size += vn_sizeof_uint32_t(&val->preserveAttachmentCount); + if (val->pPreserveAttachments) { + size += vn_sizeof_array_size(val->preserveAttachmentCount); + size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline void +vn_encode_VkSubpassDescription(struct vn_cs_encoder *enc, const VkSubpassDescription *val) +{ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint); + vn_encode_uint32_t(enc, &val->inputAttachmentCount); + if (val->pInputAttachments) { + vn_encode_array_size(enc, val->inputAttachmentCount); + for (uint32_t i = 0; i < val->inputAttachmentCount; i++) + vn_encode_VkAttachmentReference(enc, &val->pInputAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->colorAttachmentCount); + if (val->pColorAttachments) { + vn_encode_array_size(enc, val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + vn_encode_VkAttachmentReference(enc, &val->pColorAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (val->pResolveAttachments) { + vn_encode_array_size(enc, val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + vn_encode_VkAttachmentReference(enc, &val->pResolveAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment)) + vn_encode_VkAttachmentReference(enc, val->pDepthStencilAttachment); + vn_encode_uint32_t(enc, &val->preserveAttachmentCount); + if (val->pPreserveAttachments) { + vn_encode_array_size(enc, val->preserveAttachmentCount); + vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +/* struct VkSubpassDependency */ + +static inline size_t +vn_sizeof_VkSubpassDependency(const VkSubpassDependency *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->srcSubpass); + size += vn_sizeof_uint32_t(&val->dstSubpass); + size += vn_sizeof_VkFlags(&val->srcStageMask); + size += vn_sizeof_VkFlags(&val->dstStageMask); + size += vn_sizeof_VkFlags(&val->srcAccessMask); + size += vn_sizeof_VkFlags(&val->dstAccessMask); + size += vn_sizeof_VkFlags(&val->dependencyFlags); + return size; +} + +static inline void +vn_encode_VkSubpassDependency(struct vn_cs_encoder *enc, const VkSubpassDependency *val) +{ + vn_encode_uint32_t(enc, &val->srcSubpass); + vn_encode_uint32_t(enc, &val->dstSubpass); + vn_encode_VkFlags(enc, &val->srcStageMask); + vn_encode_VkFlags(enc, &val->dstStageMask); + vn_encode_VkFlags(enc, &val->srcAccessMask); + vn_encode_VkFlags(enc, &val->dstAccessMask); + vn_encode_VkFlags(enc, &val->dependencyFlags); +} + +/* struct VkRenderPassMultiviewCreateInfo chain */ + +static inline size_t +vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderPassMultiviewCreateInfo_self(const VkRenderPassMultiviewCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->subpassCount); + if (val->pViewMasks) { + size += vn_sizeof_array_size(val->subpassCount); + size += vn_sizeof_uint32_t_array(val->pViewMasks, val->subpassCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->dependencyCount); + if (val->pViewOffsets) { + size += vn_sizeof_array_size(val->dependencyCount); + size += vn_sizeof_int32_t_array(val->pViewOffsets, val->dependencyCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->correlationMaskCount); + if (val->pCorrelationMasks) { + size += vn_sizeof_array_size(val->correlationMaskCount); + size += vn_sizeof_uint32_t_array(val->pCorrelationMasks, val->correlationMaskCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderPassMultiviewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderPassMultiviewCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->subpassCount); + if (val->pViewMasks) { + vn_encode_array_size(enc, val->subpassCount); + vn_encode_uint32_t_array(enc, val->pViewMasks, val->subpassCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->dependencyCount); + if (val->pViewOffsets) { + vn_encode_array_size(enc, val->dependencyCount); + vn_encode_int32_t_array(enc, val->pViewOffsets, val->dependencyCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->correlationMaskCount); + if (val->pCorrelationMasks) { + vn_encode_array_size(enc, val->correlationMaskCount); + vn_encode_uint32_t_array(enc, val->pCorrelationMasks, val->correlationMaskCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkRenderPassMultiviewCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO }); + vn_encode_VkRenderPassMultiviewCreateInfo_pnext(enc, val->pNext); + vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, val); +} + +/* struct VkInputAttachmentAspectReference */ + +static inline size_t +vn_sizeof_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->subpass); + size += vn_sizeof_uint32_t(&val->inputAttachmentIndex); + size += vn_sizeof_VkFlags(&val->aspectMask); + return size; +} + +static inline void +vn_encode_VkInputAttachmentAspectReference(struct vn_cs_encoder *enc, const VkInputAttachmentAspectReference *val) +{ + vn_encode_uint32_t(enc, &val->subpass); + vn_encode_uint32_t(enc, &val->inputAttachmentIndex); + vn_encode_VkFlags(enc, &val->aspectMask); +} + +/* struct VkRenderPassInputAttachmentAspectCreateInfo chain */ + +static inline size_t +vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(const VkRenderPassInputAttachmentAspectCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->aspectReferenceCount); + if (val->pAspectReferences) { + size += vn_sizeof_array_size(val->aspectReferenceCount); + for (uint32_t i = 0; i < val->aspectReferenceCount; i++) + size += vn_sizeof_VkInputAttachmentAspectReference(&val->pAspectReferences[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->aspectReferenceCount); + if (val->pAspectReferences) { + vn_encode_array_size(enc, val->aspectReferenceCount); + for (uint32_t i = 0; i < val->aspectReferenceCount; i++) + vn_encode_VkInputAttachmentAspectReference(enc, &val->pAspectReferences[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkRenderPassInputAttachmentAspectCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO }); + vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(enc, val->pNext); + vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, val); +} + +/* struct VkRenderPassCreateInfo chain */ + +static inline size_t +vn_sizeof_VkRenderPassCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self((const VkRenderPassMultiviewCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self((const VkRenderPassInputAttachmentAspectCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderPassCreateInfo_self(const VkRenderPassCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->attachmentCount); + if (val->pAttachments) { + size += vn_sizeof_array_size(val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + size += vn_sizeof_VkAttachmentDescription(&val->pAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->subpassCount); + if (val->pSubpasses) { + size += vn_sizeof_array_size(val->subpassCount); + for (uint32_t i = 0; i < val->subpassCount; i++) + size += vn_sizeof_VkSubpassDescription(&val->pSubpasses[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->dependencyCount); + if (val->pDependencies) { + size += vn_sizeof_array_size(val->dependencyCount); + for (uint32_t i = 0; i < val->dependencyCount; i++) + size += vn_sizeof_VkSubpassDependency(&val->pDependencies[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkRenderPassCreateInfo(const VkRenderPassCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderPassCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkRenderPassCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderPassCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, (const VkRenderPassMultiviewCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, (const VkRenderPassInputAttachmentAspectCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderPassCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->attachmentCount); + if (val->pAttachments) { + vn_encode_array_size(enc, val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + vn_encode_VkAttachmentDescription(enc, &val->pAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->subpassCount); + if (val->pSubpasses) { + vn_encode_array_size(enc, val->subpassCount); + for (uint32_t i = 0; i < val->subpassCount; i++) + vn_encode_VkSubpassDescription(enc, &val->pSubpasses[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->dependencyCount); + if (val->pDependencies) { + vn_encode_array_size(enc, val->dependencyCount); + for (uint32_t i = 0; i < val->dependencyCount; i++) + vn_encode_VkSubpassDependency(enc, &val->pDependencies[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO }); + vn_encode_VkRenderPassCreateInfo_pnext(enc, val->pNext); + vn_encode_VkRenderPassCreateInfo_self(enc, val); +} + +/* struct VkEventCreateInfo chain */ + +static inline size_t +vn_sizeof_VkEventCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkEventCreateInfo_self(const VkEventCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline size_t +vn_sizeof_VkEventCreateInfo(const VkEventCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkEventCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkEventCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkEventCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkEventCreateInfo_self(struct vn_cs_encoder *enc, const VkEventCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); +} + +static inline void +vn_encode_VkEventCreateInfo(struct vn_cs_encoder *enc, const VkEventCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO }); + vn_encode_VkEventCreateInfo_pnext(enc, val->pNext); + vn_encode_VkEventCreateInfo_self(enc, val); +} + +/* struct VkExportFenceCreateInfo chain */ + +static inline size_t +vn_sizeof_VkExportFenceCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExportFenceCreateInfo_self(const VkExportFenceCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->handleTypes); + return size; +} + +static inline size_t +vn_sizeof_VkExportFenceCreateInfo(const VkExportFenceCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExportFenceCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkExportFenceCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkExportFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExportFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->handleTypes); +} + +static inline void +vn_encode_VkExportFenceCreateInfo(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO }); + vn_encode_VkExportFenceCreateInfo_pnext(enc, val->pNext); + vn_encode_VkExportFenceCreateInfo_self(enc, val); +} + +/* struct VkFenceCreateInfo chain */ + +static inline size_t +vn_sizeof_VkFenceCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFenceCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkExportFenceCreateInfo_self((const VkExportFenceCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFenceCreateInfo_self(const VkFenceCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline size_t +vn_sizeof_VkFenceCreateInfo(const VkFenceCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFenceCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkFenceCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkFenceCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkExportFenceCreateInfo_self(enc, (const VkExportFenceCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); +} + +static inline void +vn_encode_VkFenceCreateInfo(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO }); + vn_encode_VkFenceCreateInfo_pnext(enc, val->pNext); + vn_encode_VkFenceCreateInfo_self(enc, val); +} + +/* struct VkExportSemaphoreCreateInfo chain */ + +static inline size_t +vn_sizeof_VkExportSemaphoreCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExportSemaphoreCreateInfo_self(const VkExportSemaphoreCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->handleTypes); + return size; +} + +static inline size_t +vn_sizeof_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExportSemaphoreCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkExportSemaphoreCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkExportSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExportSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->handleTypes); +} + +static inline void +vn_encode_VkExportSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO }); + vn_encode_VkExportSemaphoreCreateInfo_pnext(enc, val->pNext); + vn_encode_VkExportSemaphoreCreateInfo_self(enc, val); +} + +/* struct VkSemaphoreTypeCreateInfo chain */ + +static inline size_t +vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSemaphoreTypeCreateInfo_self(const VkSemaphoreTypeCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSemaphoreType(&val->semaphoreType); + size += vn_sizeof_uint64_t(&val->initialValue); + return size; +} + +static inline size_t +vn_sizeof_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkSemaphoreTypeCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSemaphoreTypeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSemaphoreTypeCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSemaphoreType(enc, &val->semaphoreType); + vn_encode_uint64_t(enc, &val->initialValue); +} + +static inline void +vn_encode_VkSemaphoreTypeCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO }); + vn_encode_VkSemaphoreTypeCreateInfo_pnext(enc, val->pNext); + vn_encode_VkSemaphoreTypeCreateInfo_self(enc, val); +} + +/* struct VkSemaphoreCreateInfo chain */ + +static inline size_t +vn_sizeof_VkSemaphoreCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkExportSemaphoreCreateInfo_self((const VkExportSemaphoreCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSemaphoreCreateInfo_self(const VkSemaphoreCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline size_t +vn_sizeof_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSemaphoreCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkSemaphoreCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkExportSemaphoreCreateInfo_self(enc, (const VkExportSemaphoreCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); +} + +static inline void +vn_encode_VkSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO }); + vn_encode_VkSemaphoreCreateInfo_pnext(enc, val->pNext); + vn_encode_VkSemaphoreCreateInfo_self(enc, val); +} + +/* struct VkQueryPoolCreateInfo chain */ + +static inline size_t +vn_sizeof_VkQueryPoolCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkQueryPoolCreateInfo_self(const VkQueryPoolCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkQueryType(&val->queryType); + size += vn_sizeof_uint32_t(&val->queryCount); + size += vn_sizeof_VkFlags(&val->pipelineStatistics); + return size; +} + +static inline size_t +vn_sizeof_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkQueryPoolCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkQueryPoolCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkQueryPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkQueryPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkQueryType(enc, &val->queryType); + vn_encode_uint32_t(enc, &val->queryCount); + vn_encode_VkFlags(enc, &val->pipelineStatistics); +} + +static inline void +vn_encode_VkQueryPoolCreateInfo(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO }); + vn_encode_VkQueryPoolCreateInfo_pnext(enc, val->pNext); + vn_encode_VkQueryPoolCreateInfo_self(enc, val); +} + +/* struct VkFramebufferAttachmentImageInfo chain */ + +static inline size_t +vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFramebufferAttachmentImageInfo_self(const VkFramebufferAttachmentImageInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkFlags(&val->usage); + size += vn_sizeof_uint32_t(&val->width); + size += vn_sizeof_uint32_t(&val->height); + size += vn_sizeof_uint32_t(&val->layerCount); + size += vn_sizeof_uint32_t(&val->viewFormatCount); + if (val->pViewFormats) { + size += vn_sizeof_array_size(val->viewFormatCount); + size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(val->pNext); + size += vn_sizeof_VkFramebufferAttachmentImageInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkFramebufferAttachmentImageInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkFramebufferAttachmentImageInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkFlags(enc, &val->usage); + vn_encode_uint32_t(enc, &val->width); + vn_encode_uint32_t(enc, &val->height); + vn_encode_uint32_t(enc, &val->layerCount); + vn_encode_uint32_t(enc, &val->viewFormatCount); + if (val->pViewFormats) { + vn_encode_array_size(enc, val->viewFormatCount); + vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkFramebufferAttachmentImageInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO }); + vn_encode_VkFramebufferAttachmentImageInfo_pnext(enc, val->pNext); + vn_encode_VkFramebufferAttachmentImageInfo_self(enc, val); +} + +/* struct VkFramebufferAttachmentsCreateInfo chain */ + +static inline size_t +vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(const VkFramebufferAttachmentsCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->attachmentImageInfoCount); + if (val->pAttachmentImageInfos) { + size += vn_sizeof_array_size(val->attachmentImageInfoCount); + for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++) + size += vn_sizeof_VkFramebufferAttachmentImageInfo(&val->pAttachmentImageInfos[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkFramebufferAttachmentsCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->attachmentImageInfoCount); + if (val->pAttachmentImageInfos) { + vn_encode_array_size(enc, val->attachmentImageInfoCount); + for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++) + vn_encode_VkFramebufferAttachmentImageInfo(enc, &val->pAttachmentImageInfos[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkFramebufferAttachmentsCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO }); + vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(enc, val->pNext); + vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, val); +} + +/* struct VkFramebufferCreateInfo chain */ + +static inline size_t +vn_sizeof_VkFramebufferCreateInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFramebufferCreateInfo_pnext(pnext->pNext); + size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self((const VkFramebufferAttachmentsCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFramebufferCreateInfo_self(const VkFramebufferCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkRenderPass(&val->renderPass); + size += vn_sizeof_uint32_t(&val->attachmentCount); + if (val->pAttachments) { + size += vn_sizeof_array_size(val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + size += vn_sizeof_VkImageView(&val->pAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->width); + size += vn_sizeof_uint32_t(&val->height); + size += vn_sizeof_uint32_t(&val->layers); + return size; +} + +static inline size_t +vn_sizeof_VkFramebufferCreateInfo(const VkFramebufferCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFramebufferCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkFramebufferCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkFramebufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkFramebufferCreateInfo_pnext(enc, pnext->pNext); + vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, (const VkFramebufferAttachmentsCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkFramebufferCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkRenderPass(enc, &val->renderPass); + vn_encode_uint32_t(enc, &val->attachmentCount); + if (val->pAttachments) { + vn_encode_array_size(enc, val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + vn_encode_VkImageView(enc, &val->pAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->width); + vn_encode_uint32_t(enc, &val->height); + vn_encode_uint32_t(enc, &val->layers); +} + +static inline void +vn_encode_VkFramebufferCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO }); + vn_encode_VkFramebufferCreateInfo_pnext(enc, val->pNext); + vn_encode_VkFramebufferCreateInfo_self(enc, val); +} + +/* struct VkDrawIndirectCommand */ + +static inline size_t +vn_sizeof_VkDrawIndirectCommand(const VkDrawIndirectCommand *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->vertexCount); + size += vn_sizeof_uint32_t(&val->instanceCount); + size += vn_sizeof_uint32_t(&val->firstVertex); + size += vn_sizeof_uint32_t(&val->firstInstance); + return size; +} + +/* struct VkDrawIndexedIndirectCommand */ + +static inline size_t +vn_sizeof_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->indexCount); + size += vn_sizeof_uint32_t(&val->instanceCount); + size += vn_sizeof_uint32_t(&val->firstIndex); + size += vn_sizeof_int32_t(&val->vertexOffset); + size += vn_sizeof_uint32_t(&val->firstInstance); + return size; +} + +/* struct VkDispatchIndirectCommand */ + +static inline size_t +vn_sizeof_VkDispatchIndirectCommand(const VkDispatchIndirectCommand *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->x); + size += vn_sizeof_uint32_t(&val->y); + size += vn_sizeof_uint32_t(&val->z); + return size; +} + +/* struct VkDeviceGroupSubmitInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceGroupSubmitInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceGroupSubmitInfo_self(const VkDeviceGroupSubmitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->waitSemaphoreCount); + if (val->pWaitSemaphoreDeviceIndices) { + size += vn_sizeof_array_size(val->waitSemaphoreCount); + size += vn_sizeof_uint32_t_array(val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->commandBufferCount); + if (val->pCommandBufferDeviceMasks) { + size += vn_sizeof_array_size(val->commandBufferCount); + size += vn_sizeof_uint32_t_array(val->pCommandBufferDeviceMasks, val->commandBufferCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->signalSemaphoreCount); + if (val->pSignalSemaphoreDeviceIndices) { + size += vn_sizeof_array_size(val->signalSemaphoreCount); + size += vn_sizeof_uint32_t_array(val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceGroupSubmitInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceGroupSubmitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceGroupSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceGroupSubmitInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->waitSemaphoreCount); + if (val->pWaitSemaphoreDeviceIndices) { + vn_encode_array_size(enc, val->waitSemaphoreCount); + vn_encode_uint32_t_array(enc, val->pWaitSemaphoreDeviceIndices, val->waitSemaphoreCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->commandBufferCount); + if (val->pCommandBufferDeviceMasks) { + vn_encode_array_size(enc, val->commandBufferCount); + vn_encode_uint32_t_array(enc, val->pCommandBufferDeviceMasks, val->commandBufferCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->signalSemaphoreCount); + if (val->pSignalSemaphoreDeviceIndices) { + vn_encode_array_size(enc, val->signalSemaphoreCount); + vn_encode_uint32_t_array(enc, val->pSignalSemaphoreDeviceIndices, val->signalSemaphoreCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDeviceGroupSubmitInfo(struct vn_cs_encoder *enc, const VkDeviceGroupSubmitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO }); + vn_encode_VkDeviceGroupSubmitInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceGroupSubmitInfo_self(enc, val); +} + +/* struct VkProtectedSubmitInfo chain */ + +static inline size_t +vn_sizeof_VkProtectedSubmitInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkProtectedSubmitInfo_self(const VkProtectedSubmitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->protectedSubmit); + return size; +} + +static inline size_t +vn_sizeof_VkProtectedSubmitInfo(const VkProtectedSubmitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkProtectedSubmitInfo_pnext(val->pNext); + size += vn_sizeof_VkProtectedSubmitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkProtectedSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkProtectedSubmitInfo_self(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBool32(enc, &val->protectedSubmit); +} + +static inline void +vn_encode_VkProtectedSubmitInfo(struct vn_cs_encoder *enc, const VkProtectedSubmitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO }); + vn_encode_VkProtectedSubmitInfo_pnext(enc, val->pNext); + vn_encode_VkProtectedSubmitInfo_self(enc, val); +} + +/* struct VkSubmitInfo chain */ + +static inline size_t +vn_sizeof_VkSubmitInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext); + size += vn_sizeof_VkDeviceGroupSubmitInfo_self((const VkDeviceGroupSubmitInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext); + size += vn_sizeof_VkProtectedSubmitInfo_self((const VkProtectedSubmitInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSubmitInfo_pnext(pnext->pNext); + size += vn_sizeof_VkTimelineSemaphoreSubmitInfo_self((const VkTimelineSemaphoreSubmitInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubmitInfo_self(const VkSubmitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->waitSemaphoreCount); + if (val->pWaitSemaphores) { + size += vn_sizeof_array_size(val->waitSemaphoreCount); + for (uint32_t i = 0; i < val->waitSemaphoreCount; i++) + size += vn_sizeof_VkSemaphore(&val->pWaitSemaphores[i]); + } else { + size += vn_sizeof_array_size(0); + } + if (val->pWaitDstStageMask) { + size += vn_sizeof_array_size(val->waitSemaphoreCount); + for (uint32_t i = 0; i < val->waitSemaphoreCount; i++) + size += vn_sizeof_VkFlags(&val->pWaitDstStageMask[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->commandBufferCount); + if (val->pCommandBuffers) { + size += vn_sizeof_array_size(val->commandBufferCount); + for (uint32_t i = 0; i < val->commandBufferCount; i++) + size += vn_sizeof_VkCommandBuffer(&val->pCommandBuffers[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->signalSemaphoreCount); + if (val->pSignalSemaphores) { + size += vn_sizeof_array_size(val->signalSemaphoreCount); + for (uint32_t i = 0; i < val->signalSemaphoreCount; i++) + size += vn_sizeof_VkSemaphore(&val->pSignalSemaphores[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkSubmitInfo(const VkSubmitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubmitInfo_pnext(val->pNext); + size += vn_sizeof_VkSubmitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSubmitInfo_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_SUBMIT_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext); + vn_encode_VkDeviceGroupSubmitInfo_self(enc, (const VkDeviceGroupSubmitInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext); + vn_encode_VkProtectedSubmitInfo_self(enc, (const VkProtectedSubmitInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSubmitInfo_pnext(enc, pnext->pNext); + vn_encode_VkTimelineSemaphoreSubmitInfo_self(enc, (const VkTimelineSemaphoreSubmitInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubmitInfo_self(struct vn_cs_encoder *enc, const VkSubmitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->waitSemaphoreCount); + if (val->pWaitSemaphores) { + vn_encode_array_size(enc, val->waitSemaphoreCount); + for (uint32_t i = 0; i < val->waitSemaphoreCount; i++) + vn_encode_VkSemaphore(enc, &val->pWaitSemaphores[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (val->pWaitDstStageMask) { + vn_encode_array_size(enc, val->waitSemaphoreCount); + for (uint32_t i = 0; i < val->waitSemaphoreCount; i++) + vn_encode_VkFlags(enc, &val->pWaitDstStageMask[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->commandBufferCount); + if (val->pCommandBuffers) { + vn_encode_array_size(enc, val->commandBufferCount); + for (uint32_t i = 0; i < val->commandBufferCount; i++) + vn_encode_VkCommandBuffer(enc, &val->pCommandBuffers[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->signalSemaphoreCount); + if (val->pSignalSemaphores) { + vn_encode_array_size(enc, val->signalSemaphoreCount); + for (uint32_t i = 0; i < val->signalSemaphoreCount; i++) + vn_encode_VkSemaphore(enc, &val->pSignalSemaphores[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkSubmitInfo(struct vn_cs_encoder *enc, const VkSubmitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO }); + vn_encode_VkSubmitInfo_pnext(enc, val->pNext); + vn_encode_VkSubmitInfo_self(enc, val); +} + +/* struct VkConformanceVersion */ + +static inline size_t +vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val) +{ + size_t size = 0; + size += vn_sizeof_uint8_t(&val->major); + size += vn_sizeof_uint8_t(&val->minor); + size += vn_sizeof_uint8_t(&val->subminor); + size += vn_sizeof_uint8_t(&val->patch); + return size; +} + +static inline void +vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val) +{ + vn_decode_uint8_t(dec, &val->major); + vn_decode_uint8_t(dec, &val->minor); + vn_decode_uint8_t(dec, &val->subminor); + vn_decode_uint8_t(dec, &val->patch); +} + +static inline size_t +vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val) +{ + size_t size = 0; + /* skip val->major */ + /* skip val->minor */ + /* skip val->subminor */ + /* skip val->patch */ + return size; +} + +static inline void +vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val) +{ + /* skip val->major */ + /* skip val->minor */ + /* skip val->subminor */ + /* skip val->patch */ +} + +/* struct VkPhysicalDeviceDriverProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDriverId(&val->driverID); + size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE); + size += vn_sizeof_blob_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE); + size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE); + size += vn_sizeof_blob_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE); + size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkDriverId(dec, &val->driverID); + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE); + vn_decode_blob_array(dec, val->driverName, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE); + vn_decode_blob_array(dec, val->driverInfo, array_size); + } + vn_decode_VkConformanceVersion(dec, &val->conformanceVersion); +} + +static inline void +vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->driverID */ + /* skip val->driverName */ + /* skip val->driverInfo */ + size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->driverID */ + /* skip val->driverName */ + /* skip val->driverInfo */ + vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion); +} + +static inline void +vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES }); + vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceIDProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_array_size(VK_UUID_SIZE); + size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE); + size += vn_sizeof_array_size(VK_UUID_SIZE); + size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE); + size += vn_sizeof_array_size(VK_LUID_SIZE); + size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE); + size += vn_sizeof_uint32_t(&val->deviceNodeMask); + size += vn_sizeof_VkBool32(&val->deviceLUIDValid); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val) +{ + /* skip val->{sType,pNext} */ + { + const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE); + vn_decode_uint8_t_array(dec, val->deviceUUID, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE); + vn_decode_uint8_t_array(dec, val->driverUUID, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE); + vn_decode_uint8_t_array(dec, val->deviceLUID, array_size); + } + vn_decode_uint32_t(dec, &val->deviceNodeMask); + vn_decode_VkBool32(dec, &val->deviceLUIDValid); +} + +static inline void +vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceIDProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->deviceUUID */ + /* skip val->driverUUID */ + /* skip val->deviceLUID */ + /* skip val->deviceNodeMask */ + /* skip val->deviceLUIDValid */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->deviceUUID */ + /* skip val->driverUUID */ + /* skip val->deviceLUID */ + /* skip val->deviceNodeMask */ + /* skip val->deviceLUIDValid */ +} + +static inline void +vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES }); + vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceMultiviewProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount); + size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->maxMultiviewViewCount); + vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex); +} + +static inline void +vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxMultiviewViewCount */ + /* skip val->maxMultiviewInstanceIndex */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxMultiviewViewCount */ + /* skip val->maxMultiviewInstanceIndex */ +} + +static inline void +vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES }); + vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSubgroupProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->subgroupSize); + size += vn_sizeof_VkFlags(&val->supportedStages); + size += vn_sizeof_VkFlags(&val->supportedOperations); + size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->subgroupSize); + vn_decode_VkFlags(dec, &val->supportedStages); + vn_decode_VkFlags(dec, &val->supportedOperations); + vn_decode_VkBool32(dec, &val->quadOperationsInAllStages); +} + +static inline void +vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->subgroupSize */ + /* skip val->supportedStages */ + /* skip val->supportedOperations */ + /* skip val->quadOperationsInAllStages */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->subgroupSize */ + /* skip val->supportedStages */ + /* skip val->supportedOperations */ + /* skip val->quadOperationsInAllStages */ +} + +static inline void +vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES }); + vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDevicePointClippingProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior); +} + +static inline void +vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->pointClippingBehavior */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->pointClippingBehavior */ +} + +static inline void +vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES }); + vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceProtectedMemoryProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->protectedNoFault); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->protectedNoFault); +} + +static inline void +vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->protectedNoFault */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->protectedNoFault */ +} + +static inline void +vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES }); + vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats); + size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats); + vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping); +} + +static inline void +vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->filterMinmaxSingleComponentFormats */ + /* skip val->filterMinmaxImageComponentMapping */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->filterMinmaxSingleComponentFormats */ + /* skip val->filterMinmaxImageComponentMapping */ +} + +static inline void +vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES }); + vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceMaintenance3Properties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors); + size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->maxPerSetDescriptors); + vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize); +} + +static inline void +vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxPerSetDescriptors */ + /* skip val->maxMemoryAllocationSize */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxPerSetDescriptors */ + /* skip val->maxMemoryAllocationSize */ +} + +static inline void +vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES }); + vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceFloatControlsProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence); + size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence); + size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16); + size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32); + size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64); + size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16); + size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32); + size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64); + size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16); + size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32); + size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence); + vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence); + vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16); + vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32); + vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64); + vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16); + vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32); + vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64); + vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16); + vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32); + vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64); +} + +static inline void +vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->denormBehaviorIndependence */ + /* skip val->roundingModeIndependence */ + /* skip val->shaderSignedZeroInfNanPreserveFloat16 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat32 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat64 */ + /* skip val->shaderDenormPreserveFloat16 */ + /* skip val->shaderDenormPreserveFloat32 */ + /* skip val->shaderDenormPreserveFloat64 */ + /* skip val->shaderDenormFlushToZeroFloat16 */ + /* skip val->shaderDenormFlushToZeroFloat32 */ + /* skip val->shaderDenormFlushToZeroFloat64 */ + /* skip val->shaderRoundingModeRTEFloat16 */ + /* skip val->shaderRoundingModeRTEFloat32 */ + /* skip val->shaderRoundingModeRTEFloat64 */ + /* skip val->shaderRoundingModeRTZFloat16 */ + /* skip val->shaderRoundingModeRTZFloat32 */ + /* skip val->shaderRoundingModeRTZFloat64 */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->denormBehaviorIndependence */ + /* skip val->roundingModeIndependence */ + /* skip val->shaderSignedZeroInfNanPreserveFloat16 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat32 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat64 */ + /* skip val->shaderDenormPreserveFloat16 */ + /* skip val->shaderDenormPreserveFloat32 */ + /* skip val->shaderDenormPreserveFloat64 */ + /* skip val->shaderDenormFlushToZeroFloat16 */ + /* skip val->shaderDenormFlushToZeroFloat32 */ + /* skip val->shaderDenormFlushToZeroFloat64 */ + /* skip val->shaderRoundingModeRTEFloat16 */ + /* skip val->shaderRoundingModeRTEFloat32 */ + /* skip val->shaderRoundingModeRTEFloat64 */ + /* skip val->shaderRoundingModeRTZFloat16 */ + /* skip val->shaderRoundingModeRTZFloat32 */ + /* skip val->shaderRoundingModeRTZFloat64 */ +} + +static inline void +vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES }); + vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceDescriptorIndexingProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools); + size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments); + size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools); + vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind); + vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments); + vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments); +} + +static inline void +vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxUpdateAfterBindDescriptorsInAllPools */ + /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */ + /* skip val->shaderSampledImageArrayNonUniformIndexingNative */ + /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */ + /* skip val->shaderStorageImageArrayNonUniformIndexingNative */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */ + /* skip val->robustBufferAccessUpdateAfterBind */ + /* skip val->quadDivergentImplicitLod */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */ + /* skip val->maxPerStageUpdateAfterBindResources */ + /* skip val->maxDescriptorSetUpdateAfterBindSamplers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */ + /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxUpdateAfterBindDescriptorsInAllPools */ + /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */ + /* skip val->shaderSampledImageArrayNonUniformIndexingNative */ + /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */ + /* skip val->shaderStorageImageArrayNonUniformIndexingNative */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */ + /* skip val->robustBufferAccessUpdateAfterBind */ + /* skip val->quadDivergentImplicitLod */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */ + /* skip val->maxPerStageUpdateAfterBindResources */ + /* skip val->maxDescriptorSetUpdateAfterBindSamplers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */ + /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */ +} + +static inline void +vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES }); + vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference); +} + +static inline void +vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxTimelineSemaphoreValueDifference */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxTimelineSemaphoreValueDifference */ +} + +static inline void +vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES }); + vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceDepthStencilResolveProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes); + size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes); + size += vn_sizeof_VkBool32(&val->independentResolveNone); + size += vn_sizeof_VkBool32(&val->independentResolve); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->supportedDepthResolveModes); + vn_decode_VkFlags(dec, &val->supportedStencilResolveModes); + vn_decode_VkBool32(dec, &val->independentResolveNone); + vn_decode_VkBool32(dec, &val->independentResolve); +} + +static inline void +vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->supportedDepthResolveModes */ + /* skip val->supportedStencilResolveModes */ + /* skip val->independentResolveNone */ + /* skip val->independentResolve */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->supportedDepthResolveModes */ + /* skip val->supportedStencilResolveModes */ + /* skip val->independentResolveNone */ + /* skip val->independentResolve */ +} + +static inline void +vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES }); + vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams); + size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers); + size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize); + size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize); + size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize); + size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride); + size += vn_sizeof_VkBool32(&val->transformFeedbackQueries); + size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles); + size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect); + size += vn_sizeof_VkBool32(&val->transformFeedbackDraw); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams); + vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers); + vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize); + vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize); + vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize); + vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride); + vn_decode_VkBool32(dec, &val->transformFeedbackQueries); + vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles); + vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect); + vn_decode_VkBool32(dec, &val->transformFeedbackDraw); +} + +static inline void +vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxTransformFeedbackStreams */ + /* skip val->maxTransformFeedbackBuffers */ + /* skip val->maxTransformFeedbackBufferSize */ + /* skip val->maxTransformFeedbackStreamDataSize */ + /* skip val->maxTransformFeedbackBufferDataSize */ + /* skip val->maxTransformFeedbackBufferDataStride */ + /* skip val->transformFeedbackQueries */ + /* skip val->transformFeedbackStreamsLinesTriangles */ + /* skip val->transformFeedbackRasterizationStreamSelect */ + /* skip val->transformFeedbackDraw */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxTransformFeedbackStreams */ + /* skip val->maxTransformFeedbackBuffers */ + /* skip val->maxTransformFeedbackBufferSize */ + /* skip val->maxTransformFeedbackStreamDataSize */ + /* skip val->maxTransformFeedbackBufferDataSize */ + /* skip val->maxTransformFeedbackBufferDataStride */ + /* skip val->transformFeedbackQueries */ + /* skip val->transformFeedbackStreamsLinesTriangles */ + /* skip val->transformFeedbackRasterizationStreamSelect */ + /* skip val->transformFeedbackDraw */ +} + +static inline void +vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT }); + vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceVulkan11Properties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_array_size(VK_UUID_SIZE); + size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE); + size += vn_sizeof_array_size(VK_UUID_SIZE); + size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE); + size += vn_sizeof_array_size(VK_LUID_SIZE); + size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE); + size += vn_sizeof_uint32_t(&val->deviceNodeMask); + size += vn_sizeof_VkBool32(&val->deviceLUIDValid); + size += vn_sizeof_uint32_t(&val->subgroupSize); + size += vn_sizeof_VkFlags(&val->subgroupSupportedStages); + size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations); + size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages); + size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior); + size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount); + size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex); + size += vn_sizeof_VkBool32(&val->protectedNoFault); + size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors); + size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val) +{ + /* skip val->{sType,pNext} */ + { + const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE); + vn_decode_uint8_t_array(dec, val->deviceUUID, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE); + vn_decode_uint8_t_array(dec, val->driverUUID, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE); + vn_decode_uint8_t_array(dec, val->deviceLUID, array_size); + } + vn_decode_uint32_t(dec, &val->deviceNodeMask); + vn_decode_VkBool32(dec, &val->deviceLUIDValid); + vn_decode_uint32_t(dec, &val->subgroupSize); + vn_decode_VkFlags(dec, &val->subgroupSupportedStages); + vn_decode_VkFlags(dec, &val->subgroupSupportedOperations); + vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages); + vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior); + vn_decode_uint32_t(dec, &val->maxMultiviewViewCount); + vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex); + vn_decode_VkBool32(dec, &val->protectedNoFault); + vn_decode_uint32_t(dec, &val->maxPerSetDescriptors); + vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->deviceUUID */ + /* skip val->driverUUID */ + /* skip val->deviceLUID */ + /* skip val->deviceNodeMask */ + /* skip val->deviceLUIDValid */ + /* skip val->subgroupSize */ + /* skip val->subgroupSupportedStages */ + /* skip val->subgroupSupportedOperations */ + /* skip val->subgroupQuadOperationsInAllStages */ + /* skip val->pointClippingBehavior */ + /* skip val->maxMultiviewViewCount */ + /* skip val->maxMultiviewInstanceIndex */ + /* skip val->protectedNoFault */ + /* skip val->maxPerSetDescriptors */ + /* skip val->maxMemoryAllocationSize */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->deviceUUID */ + /* skip val->driverUUID */ + /* skip val->deviceLUID */ + /* skip val->deviceNodeMask */ + /* skip val->deviceLUIDValid */ + /* skip val->subgroupSize */ + /* skip val->subgroupSupportedStages */ + /* skip val->subgroupSupportedOperations */ + /* skip val->subgroupQuadOperationsInAllStages */ + /* skip val->pointClippingBehavior */ + /* skip val->maxMultiviewViewCount */ + /* skip val->maxMultiviewInstanceIndex */ + /* skip val->protectedNoFault */ + /* skip val->maxPerSetDescriptors */ + /* skip val->maxMemoryAllocationSize */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES }); + vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceVulkan12Properties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDriverId(&val->driverID); + size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE); + size += vn_sizeof_blob_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE); + size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE); + size += vn_sizeof_blob_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE); + size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion); + size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence); + size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence); + size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16); + size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32); + size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64); + size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16); + size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32); + size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64); + size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16); + size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32); + size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32); + size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64); + size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools); + size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative); + size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind); + size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages); + size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments); + size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages); + size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments); + size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes); + size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes); + size += vn_sizeof_VkBool32(&val->independentResolveNone); + size += vn_sizeof_VkBool32(&val->independentResolve); + size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats); + size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping); + size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference); + size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkDriverId(dec, &val->driverID); + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE); + vn_decode_blob_array(dec, val->driverName, array_size); + } + { + const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE); + vn_decode_blob_array(dec, val->driverInfo, array_size); + } + vn_decode_VkConformanceVersion(dec, &val->conformanceVersion); + vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence); + vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence); + vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16); + vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32); + vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64); + vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16); + vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32); + vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64); + vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16); + vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32); + vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32); + vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64); + vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools); + vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative); + vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind); + vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages); + vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments); + vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages); + vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments); + vn_decode_VkFlags(dec, &val->supportedDepthResolveModes); + vn_decode_VkFlags(dec, &val->supportedStencilResolveModes); + vn_decode_VkBool32(dec, &val->independentResolveNone); + vn_decode_VkBool32(dec, &val->independentResolve); + vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats); + vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping); + vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference); + vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts); +} + +static inline void +vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->driverID */ + /* skip val->driverName */ + /* skip val->driverInfo */ + size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion); + /* skip val->denormBehaviorIndependence */ + /* skip val->roundingModeIndependence */ + /* skip val->shaderSignedZeroInfNanPreserveFloat16 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat32 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat64 */ + /* skip val->shaderDenormPreserveFloat16 */ + /* skip val->shaderDenormPreserveFloat32 */ + /* skip val->shaderDenormPreserveFloat64 */ + /* skip val->shaderDenormFlushToZeroFloat16 */ + /* skip val->shaderDenormFlushToZeroFloat32 */ + /* skip val->shaderDenormFlushToZeroFloat64 */ + /* skip val->shaderRoundingModeRTEFloat16 */ + /* skip val->shaderRoundingModeRTEFloat32 */ + /* skip val->shaderRoundingModeRTEFloat64 */ + /* skip val->shaderRoundingModeRTZFloat16 */ + /* skip val->shaderRoundingModeRTZFloat32 */ + /* skip val->shaderRoundingModeRTZFloat64 */ + /* skip val->maxUpdateAfterBindDescriptorsInAllPools */ + /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */ + /* skip val->shaderSampledImageArrayNonUniformIndexingNative */ + /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */ + /* skip val->shaderStorageImageArrayNonUniformIndexingNative */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */ + /* skip val->robustBufferAccessUpdateAfterBind */ + /* skip val->quadDivergentImplicitLod */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */ + /* skip val->maxPerStageUpdateAfterBindResources */ + /* skip val->maxDescriptorSetUpdateAfterBindSamplers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */ + /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */ + /* skip val->supportedDepthResolveModes */ + /* skip val->supportedStencilResolveModes */ + /* skip val->independentResolveNone */ + /* skip val->independentResolve */ + /* skip val->filterMinmaxSingleComponentFormats */ + /* skip val->filterMinmaxImageComponentMapping */ + /* skip val->maxTimelineSemaphoreValueDifference */ + /* skip val->framebufferIntegerColorSampleCounts */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->driverID */ + /* skip val->driverName */ + /* skip val->driverInfo */ + vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion); + /* skip val->denormBehaviorIndependence */ + /* skip val->roundingModeIndependence */ + /* skip val->shaderSignedZeroInfNanPreserveFloat16 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat32 */ + /* skip val->shaderSignedZeroInfNanPreserveFloat64 */ + /* skip val->shaderDenormPreserveFloat16 */ + /* skip val->shaderDenormPreserveFloat32 */ + /* skip val->shaderDenormPreserveFloat64 */ + /* skip val->shaderDenormFlushToZeroFloat16 */ + /* skip val->shaderDenormFlushToZeroFloat32 */ + /* skip val->shaderDenormFlushToZeroFloat64 */ + /* skip val->shaderRoundingModeRTEFloat16 */ + /* skip val->shaderRoundingModeRTEFloat32 */ + /* skip val->shaderRoundingModeRTEFloat64 */ + /* skip val->shaderRoundingModeRTZFloat16 */ + /* skip val->shaderRoundingModeRTZFloat32 */ + /* skip val->shaderRoundingModeRTZFloat64 */ + /* skip val->maxUpdateAfterBindDescriptorsInAllPools */ + /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */ + /* skip val->shaderSampledImageArrayNonUniformIndexingNative */ + /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */ + /* skip val->shaderStorageImageArrayNonUniformIndexingNative */ + /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */ + /* skip val->robustBufferAccessUpdateAfterBind */ + /* skip val->quadDivergentImplicitLod */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */ + /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */ + /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */ + /* skip val->maxPerStageUpdateAfterBindResources */ + /* skip val->maxDescriptorSetUpdateAfterBindSamplers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */ + /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */ + /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */ + /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */ + /* skip val->supportedDepthResolveModes */ + /* skip val->supportedStencilResolveModes */ + /* skip val->independentResolveNone */ + /* skip val->independentResolve */ + /* skip val->filterMinmaxSingleComponentFormats */ + /* skip val->filterMinmaxImageComponentMapping */ + /* skip val->maxTimelineSemaphoreValueDifference */ + /* skip val->framebufferIntegerColorSampleCounts */ +} + +static inline void +vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES }); + vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceProperties2 chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceProperties2_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext); + vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkPhysicalDeviceProperties(dec, &val->properties); +} + +static inline void +vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceProperties2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties); +} + +static inline void +vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 }); + vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val); +} + +/* struct VkDrmFormatModifierPropertiesEXT */ + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val) +{ + size_t size = 0; + size += vn_sizeof_uint64_t(&val->drmFormatModifier); + size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount); + size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures); + return size; +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val) +{ + vn_decode_uint64_t(dec, &val->drmFormatModifier); + vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount); + vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val) +{ + size_t size = 0; + /* skip val->drmFormatModifier */ + /* skip val->drmFormatModifierPlaneCount */ + /* skip val->drmFormatModifierTilingFeatures */ + return size; +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val) +{ + /* skip val->drmFormatModifier */ + /* skip val->drmFormatModifierPlaneCount */ + /* skip val->drmFormatModifierTilingFeatures */ +} + +/* struct VkDrmFormatModifierPropertiesListEXT chain */ + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->drmFormatModifierCount); + if (val->pDrmFormatModifierProperties) { + size += vn_sizeof_array_size(val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val); + + return size; +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->drmFormatModifierCount); + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]); + } else { + vn_decode_array_size(dec, 0); + val->pDrmFormatModifierProperties = NULL; + } +} + +static inline void +vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT); + + assert(val->sType == stype); + vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext); + vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->drmFormatModifierCount */ + if (val->pDrmFormatModifierProperties) { + size += vn_sizeof_array_size(val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->drmFormatModifierCount */ + if (val->pDrmFormatModifierProperties) { + vn_encode_array_size(enc, val->drmFormatModifierCount); + for (uint32_t i = 0; i < val->drmFormatModifierCount; i++) + vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT }); + vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext); + vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val); +} + +/* struct VkFormatProperties2 chain */ + +static inline size_t +vn_sizeof_VkFormatProperties2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFormatProperties(&val->formatProperties); + return size; +} + +static inline size_t +vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFormatProperties2_pnext(val->pNext); + size += vn_sizeof_VkFormatProperties2_self(val); + + return size; +} + +static inline void +vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext); + vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFormatProperties(dec, &val->formatProperties); +} + +static inline void +vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2); + + assert(val->sType == stype); + vn_decode_VkFormatProperties2_pnext(dec, val->pNext); + vn_decode_VkFormatProperties2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkFormatProperties2_pnext_partial(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties); + return size; +} + +static inline size_t +vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext); + size += vn_sizeof_VkFormatProperties2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFormatProperties_partial(enc, &val->formatProperties); +} + +static inline void +vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 }); + vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext); + vn_encode_VkFormatProperties2_self_partial(enc, val); +} + +/* struct VkExternalMemoryProperties */ + +static inline size_t +vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val) +{ + size_t size = 0; + size += vn_sizeof_VkFlags(&val->externalMemoryFeatures); + size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes); + size += vn_sizeof_VkFlags(&val->compatibleHandleTypes); + return size; +} + +static inline void +vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val) +{ + vn_decode_VkFlags(dec, &val->externalMemoryFeatures); + vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes); + vn_decode_VkFlags(dec, &val->compatibleHandleTypes); +} + +static inline size_t +vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val) +{ + size_t size = 0; + /* skip val->externalMemoryFeatures */ + /* skip val->exportFromImportedHandleTypes */ + /* skip val->compatibleHandleTypes */ + return size; +} + +static inline void +vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val) +{ + /* skip val->externalMemoryFeatures */ + /* skip val->exportFromImportedHandleTypes */ + /* skip val->compatibleHandleTypes */ +} + +/* struct VkExternalImageFormatProperties chain */ + +static inline size_t +vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties); + return size; +} + +static inline size_t +vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext); + size += vn_sizeof_VkExternalImageFormatProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties); +} + +static inline void +vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext); + vn_decode_VkExternalImageFormatProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties); + return size; +} + +static inline size_t +vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties); +} + +static inline void +vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES }); + vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext); + vn_encode_VkExternalImageFormatProperties_self_partial(enc, val); +} + +/* struct VkSamplerYcbcrConversionImageFormatProperties chain */ + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount); + return size; +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount); +} + +static inline void +vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext); + vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->combinedImageSamplerDescriptorCount */ + return size; +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->combinedImageSamplerDescriptorCount */ +} + +static inline void +vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES }); + vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext); + vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val); +} + +/* struct VkImageFormatProperties2 chain */ + +static inline size_t +vn_sizeof_VkImageFormatProperties2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties); + return size; +} + +static inline size_t +vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext); + size += vn_sizeof_VkImageFormatProperties2_self(val); + + return size; +} + +static inline void +vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext); + vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext); + vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties); +} + +static inline void +vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2); + + assert(val->sType == stype); + vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext); + vn_decode_VkImageFormatProperties2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext); + return size; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties); + return size; +} + +static inline size_t +vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext); + size += vn_sizeof_VkImageFormatProperties2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext); + return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext); + vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties); +} + +static inline void +vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 }); + vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext); + vn_encode_VkImageFormatProperties2_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceExternalImageFormatInfo chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO }); + vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val); +} + +/* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint64_t(&val->drmFormatModifier); + size += vn_sizeof_VkSharingMode(&val->sharingMode); + size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount); + if (val->pQueueFamilyIndices) { + size += vn_sizeof_array_size(val->queueFamilyIndexCount); + size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint64_t(enc, &val->drmFormatModifier); + vn_encode_VkSharingMode(enc, &val->sharingMode); + vn_encode_uint32_t(enc, &val->queueFamilyIndexCount); + if (val->pQueueFamilyIndices) { + vn_encode_array_size(enc, val->queueFamilyIndexCount); + vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT }); + vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val); +} + +/* struct VkPhysicalDeviceImageFormatInfo2 chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext); + size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext); + size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext); + return size; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext); + size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkImageType(&val->type); + size += vn_sizeof_VkImageTiling(&val->tiling); + size += vn_sizeof_VkFlags(&val->usage); + size += vn_sizeof_VkFlags(&val->flags); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext); + vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext); + vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext); + return; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext); + vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkImageType(enc, &val->type); + vn_encode_VkImageTiling(enc, &val->tiling); + vn_encode_VkFlags(enc, &val->usage); + vn_encode_VkFlags(enc, &val->flags); +} + +static inline void +vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 }); + vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val); +} + +/* struct VkQueueFamilyProperties2 chain */ + +static inline size_t +vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties); + return size; +} + +static inline size_t +vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext); + size += vn_sizeof_VkQueueFamilyProperties2_self(val); + + return size; +} + +static inline void +vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties); +} + +static inline void +vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2); + + assert(val->sType == stype); + vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext); + vn_decode_VkQueueFamilyProperties2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties); + return size; +} + +static inline size_t +vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext); + size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties); +} + +static inline void +vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 }); + vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext); + vn_encode_VkQueueFamilyProperties2_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceMemoryProperties2 chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties); +} + +static inline void +vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties); +} + +static inline void +vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 }); + vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val); +} + +/* struct VkSparseImageFormatProperties2 chain */ + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSparseImageFormatProperties(&val->properties); + return size; +} + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext); + size += vn_sizeof_VkSparseImageFormatProperties2_self(val); + + return size; +} + +static inline void +vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkSparseImageFormatProperties(dec, &val->properties); +} + +static inline void +vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2); + + assert(val->sType == stype); + vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext); + vn_decode_VkSparseImageFormatProperties2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties); + return size; +} + +static inline size_t +vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext); + size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties); +} + +static inline void +vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 }); + vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext); + vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkImageType(&val->type); + size += vn_sizeof_VkSampleCountFlagBits(&val->samples); + size += vn_sizeof_VkFlags(&val->usage); + size += vn_sizeof_VkImageTiling(&val->tiling); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkImageType(enc, &val->type); + vn_encode_VkSampleCountFlagBits(enc, &val->samples); + vn_encode_VkFlags(enc, &val->usage); + vn_encode_VkImageTiling(enc, &val->tiling); +} + +static inline void +vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 }); + vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val); +} + +/* struct VkPhysicalDeviceExternalBufferInfo chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkFlags(&val->usage); + size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkFlags(enc, &val->usage); + vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO }); + vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val); +} + +/* struct VkExternalBufferProperties chain */ + +static inline size_t +vn_sizeof_VkExternalBufferProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties); + return size; +} + +static inline size_t +vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext); + size += vn_sizeof_VkExternalBufferProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties); +} + +static inline void +vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext); + vn_decode_VkExternalBufferProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties); + return size; +} + +static inline size_t +vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkExternalBufferProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties); +} + +static inline void +vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES }); + vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext); + vn_encode_VkExternalBufferProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceExternalSemaphoreInfo chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext); + size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext); + vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO }); + vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val); +} + +/* struct VkExternalSemaphoreProperties chain */ + +static inline size_t +vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes); + size += vn_sizeof_VkFlags(&val->compatibleHandleTypes); + size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures); + return size; +} + +static inline size_t +vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext); + size += vn_sizeof_VkExternalSemaphoreProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes); + vn_decode_VkFlags(dec, &val->compatibleHandleTypes); + vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures); +} + +static inline void +vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext); + vn_decode_VkExternalSemaphoreProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->exportFromImportedHandleTypes */ + /* skip val->compatibleHandleTypes */ + /* skip val->externalSemaphoreFeatures */ + return size; +} + +static inline size_t +vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->exportFromImportedHandleTypes */ + /* skip val->compatibleHandleTypes */ + /* skip val->externalSemaphoreFeatures */ +} + +static inline void +vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES }); + vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext); + vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceExternalFenceInfo chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType); +} + +static inline void +vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO }); + vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext); + vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val); +} + +/* struct VkExternalFenceProperties chain */ + +static inline size_t +vn_sizeof_VkExternalFenceProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes); + size += vn_sizeof_VkFlags(&val->compatibleHandleTypes); + size += vn_sizeof_VkFlags(&val->externalFenceFeatures); + return size; +} + +static inline size_t +vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext); + size += vn_sizeof_VkExternalFenceProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes); + vn_decode_VkFlags(dec, &val->compatibleHandleTypes); + vn_decode_VkFlags(dec, &val->externalFenceFeatures); +} + +static inline void +vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext); + vn_decode_VkExternalFenceProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->exportFromImportedHandleTypes */ + /* skip val->compatibleHandleTypes */ + /* skip val->externalFenceFeatures */ + return size; +} + +static inline size_t +vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkExternalFenceProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->exportFromImportedHandleTypes */ + /* skip val->compatibleHandleTypes */ + /* skip val->externalFenceFeatures */ +} + +static inline void +vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES }); + vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext); + vn_encode_VkExternalFenceProperties_self_partial(enc, val); +} + +/* struct VkPhysicalDeviceGroupProperties chain */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->physicalDeviceCount); + size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE); + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) + size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]); + size += vn_sizeof_VkBool32(&val->subsetAllocation); + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext); + size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val); + + return size; +} + +static inline void +vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->physicalDeviceCount); + { + vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE); + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) + vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]); + } + vn_decode_VkBool32(dec, &val->subsetAllocation); +} + +static inline void +vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES); + + assert(val->sType == stype); + vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext); + vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->physicalDeviceCount */ + size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE); + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) + size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]); + /* skip val->subsetAllocation */ + return size; +} + +static inline size_t +vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext); + size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->physicalDeviceCount */ + vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE); + for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) + vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]); + /* skip val->subsetAllocation */ +} + +static inline void +vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES }); + vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext); + vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val); +} + +/* struct VkBindBufferMemoryDeviceGroupInfo chain */ + +static inline size_t +vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self(const VkBindBufferMemoryDeviceGroupInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->deviceIndexCount); + if (val->pDeviceIndices) { + size += vn_sizeof_array_size(val->deviceIndexCount); + size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_pnext(val->pNext); + size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBindBufferMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindBufferMemoryDeviceGroupInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->deviceIndexCount); + if (val->pDeviceIndices) { + vn_encode_array_size(enc, val->deviceIndexCount); + vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkBindBufferMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindBufferMemoryDeviceGroupInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO }); + vn_encode_VkBindBufferMemoryDeviceGroupInfo_pnext(enc, val->pNext); + vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(enc, val); +} + +static inline void +vn_decode_VkBindBufferMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindBufferMemoryDeviceGroupInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->deviceIndexCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount); + vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size); + } else { + vn_decode_array_size(dec, 0); + val->pDeviceIndices = NULL; + } +} + +static inline void +vn_decode_VkBindBufferMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindBufferMemoryDeviceGroupInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO); + + assert(val->sType == stype); + vn_decode_VkBindBufferMemoryDeviceGroupInfo_pnext(dec, val->pNext); + vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(dec, val); +} + +/* struct VkBindBufferMemoryInfo chain */ + +static inline size_t +vn_sizeof_VkBindBufferMemoryInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBindBufferMemoryInfo_pnext(pnext->pNext); + size += vn_sizeof_VkBindBufferMemoryDeviceGroupInfo_self((const VkBindBufferMemoryDeviceGroupInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBindBufferMemoryInfo_self(const VkBindBufferMemoryInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBuffer(&val->buffer); + size += vn_sizeof_VkDeviceMemory(&val->memory); + size += vn_sizeof_VkDeviceSize(&val->memoryOffset); + return size; +} + +static inline size_t +vn_sizeof_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBindBufferMemoryInfo_pnext(val->pNext); + size += vn_sizeof_VkBindBufferMemoryInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBindBufferMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBindBufferMemoryInfo_pnext(enc, pnext->pNext); + vn_encode_VkBindBufferMemoryDeviceGroupInfo_self(enc, (const VkBindBufferMemoryDeviceGroupInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBindBufferMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindBufferMemoryInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBuffer(enc, &val->buffer); + vn_encode_VkDeviceMemory(enc, &val->memory); + vn_encode_VkDeviceSize(enc, &val->memoryOffset); +} + +static inline void +vn_encode_VkBindBufferMemoryInfo(struct vn_cs_encoder *enc, const VkBindBufferMemoryInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO }); + vn_encode_VkBindBufferMemoryInfo_pnext(enc, val->pNext); + vn_encode_VkBindBufferMemoryInfo_self(enc, val); +} + +static inline void +vn_decode_VkBindBufferMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + vn_decode_VkBindBufferMemoryInfo_pnext(dec, pnext->pNext); + vn_decode_VkBindBufferMemoryDeviceGroupInfo_self(dec, (VkBindBufferMemoryDeviceGroupInfo *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkBindBufferMemoryInfo_self(struct vn_cs_decoder *dec, VkBindBufferMemoryInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBuffer(dec, &val->buffer); + vn_decode_VkDeviceMemory(dec, &val->memory); + vn_decode_VkDeviceSize(dec, &val->memoryOffset); +} + +static inline void +vn_decode_VkBindBufferMemoryInfo(struct vn_cs_decoder *dec, VkBindBufferMemoryInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO); + + assert(val->sType == stype); + vn_decode_VkBindBufferMemoryInfo_pnext(dec, val->pNext); + vn_decode_VkBindBufferMemoryInfo_self(dec, val); +} + +/* struct VkBindImageMemoryDeviceGroupInfo chain */ + +static inline size_t +vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(const VkBindImageMemoryDeviceGroupInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->deviceIndexCount); + if (val->pDeviceIndices) { + size += vn_sizeof_array_size(val->deviceIndexCount); + size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->splitInstanceBindRegionCount); + if (val->pSplitInstanceBindRegions) { + size += vn_sizeof_array_size(val->splitInstanceBindRegionCount); + for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++) + size += vn_sizeof_VkRect2D(&val->pSplitInstanceBindRegions[i]); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(val->pNext); + size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->deviceIndexCount); + if (val->pDeviceIndices) { + vn_encode_array_size(enc, val->deviceIndexCount); + vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->splitInstanceBindRegionCount); + if (val->pSplitInstanceBindRegions) { + vn_encode_array_size(enc, val->splitInstanceBindRegionCount); + for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++) + vn_encode_VkRect2D(enc, &val->pSplitInstanceBindRegions[i]); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO }); + vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(enc, val->pNext); + vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, val); +} + +static inline void +vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->deviceIndexCount); + if (vn_peek_array_size(dec)) { + const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount); + vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size); + } else { + vn_decode_array_size(dec, 0); + val->pDeviceIndices = NULL; + } + vn_decode_uint32_t(dec, &val->splitInstanceBindRegionCount); + if (vn_peek_array_size(dec)) { + vn_decode_array_size(dec, val->splitInstanceBindRegionCount); + for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++) + vn_decode_VkRect2D(dec, &((VkRect2D *)val->pSplitInstanceBindRegions)[i]); + } else { + vn_decode_array_size(dec, 0); + val->pSplitInstanceBindRegions = NULL; + } +} + +static inline void +vn_decode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO); + + assert(val->sType == stype); + vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext(dec, val->pNext); + vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, val); +} + +/* struct VkBindImagePlaneMemoryInfo chain */ + +static inline size_t +vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBindImagePlaneMemoryInfo_self(const VkBindImagePlaneMemoryInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect); + return size; +} + +static inline size_t +vn_sizeof_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(val->pNext); + size += vn_sizeof_VkBindImagePlaneMemoryInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect); +} + +static inline void +vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO }); + vn_encode_VkBindImagePlaneMemoryInfo_pnext(enc, val->pNext); + vn_encode_VkBindImagePlaneMemoryInfo_self(enc, val); +} + +static inline void +vn_decode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect); +} + +static inline void +vn_decode_VkBindImagePlaneMemoryInfo(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO); + + assert(val->sType == stype); + vn_decode_VkBindImagePlaneMemoryInfo_pnext(dec, val->pNext); + vn_decode_VkBindImagePlaneMemoryInfo_self(dec, val); +} + +/* struct VkBindImageMemoryInfo chain */ + +static inline size_t +vn_sizeof_VkBindImageMemoryInfo_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext); + size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self((const VkBindImageMemoryDeviceGroupInfo *)pnext); + return size; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext); + size += vn_sizeof_VkBindImagePlaneMemoryInfo_self((const VkBindImagePlaneMemoryInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBindImageMemoryInfo_self(const VkBindImageMemoryInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->image); + size += vn_sizeof_VkDeviceMemory(&val->memory); + size += vn_sizeof_VkDeviceSize(&val->memoryOffset); + return size; +} + +static inline size_t +vn_sizeof_VkBindImageMemoryInfo(const VkBindImageMemoryInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBindImageMemoryInfo_pnext(val->pNext); + size += vn_sizeof_VkBindImageMemoryInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext); + vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, (const VkBindImageMemoryDeviceGroupInfo *)pnext); + return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext); + vn_encode_VkBindImagePlaneMemoryInfo_self(enc, (const VkBindImagePlaneMemoryInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->image); + vn_encode_VkDeviceMemory(enc, &val->memory); + vn_encode_VkDeviceSize(enc, &val->memoryOffset); +} + +static inline void +vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO }); + vn_encode_VkBindImageMemoryInfo_pnext(enc, val->pNext); + vn_encode_VkBindImageMemoryInfo_self(enc, val); +} + +static inline void +vn_decode_VkBindImageMemoryInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext); + vn_decode_VkBindImageMemoryDeviceGroupInfo_self(dec, (VkBindImageMemoryDeviceGroupInfo *)pnext); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + vn_decode_VkBindImageMemoryInfo_pnext(dec, pnext->pNext); + vn_decode_VkBindImagePlaneMemoryInfo_self(dec, (VkBindImagePlaneMemoryInfo *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkBindImageMemoryInfo_self(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkImage(dec, &val->image); + vn_decode_VkDeviceMemory(dec, &val->memory); + vn_decode_VkDeviceSize(dec, &val->memoryOffset); +} + +static inline void +vn_decode_VkBindImageMemoryInfo(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO); + + assert(val->sType == stype); + vn_decode_VkBindImageMemoryInfo_pnext(dec, val->pNext); + vn_decode_VkBindImageMemoryInfo_self(dec, val); +} + +/* struct VkDescriptorUpdateTemplateEntry */ + +static inline size_t +vn_sizeof_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->dstBinding); + size += vn_sizeof_uint32_t(&val->dstArrayElement); + size += vn_sizeof_uint32_t(&val->descriptorCount); + size += vn_sizeof_VkDescriptorType(&val->descriptorType); + size += vn_sizeof_size_t(&val->offset); + size += vn_sizeof_size_t(&val->stride); + return size; +} + +static inline void +vn_encode_VkDescriptorUpdateTemplateEntry(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateEntry *val) +{ + vn_encode_uint32_t(enc, &val->dstBinding); + vn_encode_uint32_t(enc, &val->dstArrayElement); + vn_encode_uint32_t(enc, &val->descriptorCount); + vn_encode_VkDescriptorType(enc, &val->descriptorType); + vn_encode_size_t(enc, &val->offset); + vn_encode_size_t(enc, &val->stride); +} + +/* struct VkDescriptorUpdateTemplateCreateInfo chain */ + +static inline size_t +vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(const VkDescriptorUpdateTemplateCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->descriptorUpdateEntryCount); + if (val->pDescriptorUpdateEntries) { + size += vn_sizeof_array_size(val->descriptorUpdateEntryCount); + for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++) + size += vn_sizeof_VkDescriptorUpdateTemplateEntry(&val->pDescriptorUpdateEntries[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_VkDescriptorUpdateTemplateType(&val->templateType); + size += vn_sizeof_VkDescriptorSetLayout(&val->descriptorSetLayout); + size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint); + size += vn_sizeof_VkPipelineLayout(&val->pipelineLayout); + size += vn_sizeof_uint32_t(&val->set); + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->descriptorUpdateEntryCount); + if (val->pDescriptorUpdateEntries) { + vn_encode_array_size(enc, val->descriptorUpdateEntryCount); + for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++) + vn_encode_VkDescriptorUpdateTemplateEntry(enc, &val->pDescriptorUpdateEntries[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_VkDescriptorUpdateTemplateType(enc, &val->templateType); + vn_encode_VkDescriptorSetLayout(enc, &val->descriptorSetLayout); + vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint); + vn_encode_VkPipelineLayout(enc, &val->pipelineLayout); + vn_encode_uint32_t(enc, &val->set); +} + +static inline void +vn_encode_VkDescriptorUpdateTemplateCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO }); + vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(enc, val->pNext); + vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(enc, val); +} + +/* struct VkBufferMemoryRequirementsInfo2 chain */ + +static inline size_t +vn_sizeof_VkBufferMemoryRequirementsInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferMemoryRequirementsInfo2_self(const VkBufferMemoryRequirementsInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBuffer(&val->buffer); + return size; +} + +static inline size_t +vn_sizeof_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferMemoryRequirementsInfo2_pnext(val->pNext); + size += vn_sizeof_VkBufferMemoryRequirementsInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkBufferMemoryRequirementsInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBuffer(enc, &val->buffer); +} + +static inline void +vn_encode_VkBufferMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkBufferMemoryRequirementsInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 }); + vn_encode_VkBufferMemoryRequirementsInfo2_pnext(enc, val->pNext); + vn_encode_VkBufferMemoryRequirementsInfo2_self(enc, val); +} + +/* struct VkImagePlaneMemoryRequirementsInfo chain */ + +static inline size_t +vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(const VkImagePlaneMemoryRequirementsInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect); + return size; +} + +static inline size_t +vn_sizeof_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(val->pNext); + size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImagePlaneMemoryRequirementsInfo_self(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect); +} + +static inline void +vn_encode_VkImagePlaneMemoryRequirementsInfo(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO }); + vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(enc, val->pNext); + vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, val); +} + +/* struct VkImageMemoryRequirementsInfo2 chain */ + +static inline size_t +vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(pnext->pNext); + size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self((const VkImagePlaneMemoryRequirementsInfo *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageMemoryRequirementsInfo2_self(const VkImageMemoryRequirementsInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->image); + return size; +} + +static inline size_t +vn_sizeof_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(val->pNext); + size += vn_sizeof_VkImageMemoryRequirementsInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkImageMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, pnext->pNext); + vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, (const VkImagePlaneMemoryRequirementsInfo *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->image); +} + +static inline void +vn_encode_VkImageMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 }); + vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, val->pNext); + vn_encode_VkImageMemoryRequirementsInfo2_self(enc, val); +} + +/* struct VkImageSparseMemoryRequirementsInfo2 chain */ + +static inline size_t +vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(const VkImageSparseMemoryRequirementsInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImage(&val->image); + return size; +} + +static inline size_t +vn_sizeof_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(val->pNext); + size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageSparseMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImage(enc, &val->image); +} + +static inline void +vn_encode_VkImageSparseMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 }); + vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(enc, val->pNext); + vn_encode_VkImageSparseMemoryRequirementsInfo2_self(enc, val); +} + +/* struct VkMemoryDedicatedRequirements chain */ + +static inline size_t +vn_sizeof_VkMemoryDedicatedRequirements_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedRequirements_self(const VkMemoryDedicatedRequirements *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->prefersDedicatedAllocation); + size += vn_sizeof_VkBool32(&val->requiresDedicatedAllocation); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryDedicatedRequirements_pnext(val->pNext); + size += vn_sizeof_VkMemoryDedicatedRequirements_self(val); + + return size; +} + +static inline void +vn_decode_VkMemoryDedicatedRequirements_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkMemoryDedicatedRequirements_self(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->prefersDedicatedAllocation); + vn_decode_VkBool32(dec, &val->requiresDedicatedAllocation); +} + +static inline void +vn_decode_VkMemoryDedicatedRequirements(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS); + + assert(val->sType == stype); + vn_decode_VkMemoryDedicatedRequirements_pnext(dec, val->pNext); + vn_decode_VkMemoryDedicatedRequirements_self(dec, val); +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedRequirements_self_partial(const VkMemoryDedicatedRequirements *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->prefersDedicatedAllocation */ + /* skip val->requiresDedicatedAllocation */ + return size; +} + +static inline size_t +vn_sizeof_VkMemoryDedicatedRequirements_partial(const VkMemoryDedicatedRequirements *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(val->pNext); + size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkMemoryDedicatedRequirements_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryDedicatedRequirements_self_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->prefersDedicatedAllocation */ + /* skip val->requiresDedicatedAllocation */ +} + +static inline void +vn_encode_VkMemoryDedicatedRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS }); + vn_encode_VkMemoryDedicatedRequirements_pnext_partial(enc, val->pNext); + vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, val); +} + +/* struct VkMemoryRequirements2 chain */ + +static inline size_t +vn_sizeof_VkMemoryRequirements2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkMemoryRequirements2_pnext(pnext->pNext); + size += vn_sizeof_VkMemoryDedicatedRequirements_self((const VkMemoryDedicatedRequirements *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryRequirements2_self(const VkMemoryRequirements2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkMemoryRequirements(&val->memoryRequirements); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryRequirements2(const VkMemoryRequirements2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryRequirements2_pnext(val->pNext); + size += vn_sizeof_VkMemoryRequirements2_self(val); + + return size; +} + +static inline void +vn_decode_VkMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + vn_decode_VkMemoryRequirements2_pnext(dec, pnext->pNext); + vn_decode_VkMemoryDedicatedRequirements_self(dec, (VkMemoryDedicatedRequirements *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkMemoryRequirements2_self(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkMemoryRequirements(dec, &val->memoryRequirements); +} + +static inline void +vn_decode_VkMemoryRequirements2(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2); + + assert(val->sType == stype); + vn_decode_VkMemoryRequirements2_pnext(dec, val->pNext); + vn_decode_VkMemoryRequirements2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkMemoryRequirements2_pnext_partial(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkMemoryRequirements2_pnext_partial(pnext->pNext); + size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial((const VkMemoryDedicatedRequirements *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkMemoryRequirements2_self_partial(const VkMemoryRequirements2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkMemoryRequirements_partial(&val->memoryRequirements); + return size; +} + +static inline size_t +vn_sizeof_VkMemoryRequirements2_partial(const VkMemoryRequirements2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkMemoryRequirements2_pnext_partial(val->pNext); + size += vn_sizeof_VkMemoryRequirements2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkMemoryRequirements2_pnext_partial(enc, pnext->pNext); + vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, (const VkMemoryDedicatedRequirements *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkMemoryRequirements_partial(enc, &val->memoryRequirements); +} + +static inline void +vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 }); + vn_encode_VkMemoryRequirements2_pnext_partial(enc, val->pNext); + vn_encode_VkMemoryRequirements2_self_partial(enc, val); +} + +/* struct VkSparseImageMemoryRequirements2 chain */ + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements2_self(const VkSparseImageMemoryRequirements2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSparseImageMemoryRequirements(&val->memoryRequirements); + return size; +} + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext(val->pNext); + size += vn_sizeof_VkSparseImageMemoryRequirements2_self(val); + + return size; +} + +static inline void +vn_decode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkSparseImageMemoryRequirements2_self(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkSparseImageMemoryRequirements(dec, &val->memoryRequirements); +} + +static inline void +vn_decode_VkSparseImageMemoryRequirements2(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2); + + assert(val->sType == stype); + vn_decode_VkSparseImageMemoryRequirements2_pnext(dec, val->pNext); + vn_decode_VkSparseImageMemoryRequirements2_self(dec, val); +} + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(const VkSparseImageMemoryRequirements2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&val->memoryRequirements); + return size; +} + +static inline size_t +vn_sizeof_VkSparseImageMemoryRequirements2_partial(const VkSparseImageMemoryRequirements2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(val->pNext); + size += vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSparseImageMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSparseImageMemoryRequirements_partial(enc, &val->memoryRequirements); +} + +static inline void +vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 }); + vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(enc, val->pNext); + vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val); +} + +/* struct VkSamplerYcbcrConversionCreateInfo chain */ + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(const VkSamplerYcbcrConversionCreateInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkSamplerYcbcrModelConversion(&val->ycbcrModel); + size += vn_sizeof_VkSamplerYcbcrRange(&val->ycbcrRange); + size += vn_sizeof_VkComponentMapping(&val->components); + size += vn_sizeof_VkChromaLocation(&val->xChromaOffset); + size += vn_sizeof_VkChromaLocation(&val->yChromaOffset); + size += vn_sizeof_VkFilter(&val->chromaFilter); + size += vn_sizeof_VkBool32(&val->forceExplicitReconstruction); + return size; +} + +static inline size_t +vn_sizeof_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(val->pNext); + size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSamplerYcbcrConversionCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkSamplerYcbcrModelConversion(enc, &val->ycbcrModel); + vn_encode_VkSamplerYcbcrRange(enc, &val->ycbcrRange); + vn_encode_VkComponentMapping(enc, &val->components); + vn_encode_VkChromaLocation(enc, &val->xChromaOffset); + vn_encode_VkChromaLocation(enc, &val->yChromaOffset); + vn_encode_VkFilter(enc, &val->chromaFilter); + vn_encode_VkBool32(enc, &val->forceExplicitReconstruction); +} + +static inline void +vn_encode_VkSamplerYcbcrConversionCreateInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO }); + vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(enc, val->pNext); + vn_encode_VkSamplerYcbcrConversionCreateInfo_self(enc, val); +} + +/* struct VkDeviceQueueInfo2 chain */ + +static inline size_t +vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->queueFamilyIndex); + size += vn_sizeof_uint32_t(&val->queueIndex); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext); + size += vn_sizeof_VkDeviceQueueInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->queueFamilyIndex); + vn_encode_uint32_t(enc, &val->queueIndex); +} + +static inline void +vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 }); + vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext); + vn_encode_VkDeviceQueueInfo2_self(enc, val); +} + +/* struct VkDescriptorSetVariableDescriptorCountLayoutSupport chain */ + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->maxVariableDescriptorCount); + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(val->pNext); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(val); + + return size; +} + +static inline void +vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint32_t(dec, &val->maxVariableDescriptorCount); +} + +static inline void +vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT); + + assert(val->sType == stype); + vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(dec, val->pNext); + vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, val); +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->maxVariableDescriptorCount */ + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(val->pNext); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->maxVariableDescriptorCount */ +} + +static inline void +vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT }); + vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(enc, val->pNext); + vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, val); +} + +/* struct VkDescriptorSetLayoutSupport chain */ + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutSupport_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(pnext->pNext); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutSupport_self(const VkDescriptorSetLayoutSupport *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBool32(&val->supported); + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(val->pNext); + size += vn_sizeof_VkDescriptorSetLayoutSupport_self(val); + + return size; +} + +static inline void +vn_decode_VkDescriptorSetLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val) +{ + VkBaseOutStructure *pnext = (VkBaseOutStructure *)val; + VkStructureType stype; + + if (!vn_decode_simple_pointer(dec)) + return; + + vn_decode_VkStructureType(dec, &stype); + while (true) { + assert(pnext); + if (pnext->sType == stype) + break; + } + + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, pnext->pNext); + vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, (VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext); + break; + default: + assert(false); + break; + } +} + +static inline void +vn_decode_VkDescriptorSetLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBool32(dec, &val->supported); +} + +static inline void +vn_decode_VkDescriptorSetLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT); + + assert(val->sType == stype); + vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, val->pNext); + vn_decode_VkDescriptorSetLayoutSupport_self(dec, val); +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(pnext->pNext); + size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(const VkDescriptorSetLayoutSupport *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->supported */ + return size; +} + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutSupport_partial(const VkDescriptorSetLayoutSupport *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(val->pNext); + size += vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, pnext->pNext); + vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDescriptorSetLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->supported */ +} + +static inline void +vn_encode_VkDescriptorSetLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT }); + vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, val->pNext); + vn_encode_VkDescriptorSetLayoutSupport_self_partial(enc, val); +} + +/* struct VkAttachmentDescriptionStencilLayout chain */ + +static inline size_t +vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageLayout(&val->stencilInitialLayout); + size += vn_sizeof_VkImageLayout(&val->stencilFinalLayout); + return size; +} + +static inline size_t +vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(val->pNext); + size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self(val); + + return size; +} + +static inline void +vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageLayout(enc, &val->stencilInitialLayout); + vn_encode_VkImageLayout(enc, &val->stencilFinalLayout); +} + +static inline void +vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT }); + vn_encode_VkAttachmentDescriptionStencilLayout_pnext(enc, val->pNext); + vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, val); +} + +/* struct VkAttachmentDescription2 chain */ + +static inline size_t +vn_sizeof_VkAttachmentDescription2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkAttachmentDescription2_pnext(pnext->pNext); + size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self((const VkAttachmentDescriptionStencilLayout *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkFormat(&val->format); + size += vn_sizeof_VkSampleCountFlagBits(&val->samples); + size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp); + size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp); + size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp); + size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp); + size += vn_sizeof_VkImageLayout(&val->initialLayout); + size += vn_sizeof_VkImageLayout(&val->finalLayout); + return size; +} + +static inline size_t +vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkAttachmentDescription2_pnext(val->pNext); + size += vn_sizeof_VkAttachmentDescription2_self(val); + + return size; +} + +static inline void +vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkAttachmentDescription2_pnext(enc, pnext->pNext); + vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, (const VkAttachmentDescriptionStencilLayout *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkFormat(enc, &val->format); + vn_encode_VkSampleCountFlagBits(enc, &val->samples); + vn_encode_VkAttachmentLoadOp(enc, &val->loadOp); + vn_encode_VkAttachmentStoreOp(enc, &val->storeOp); + vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp); + vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp); + vn_encode_VkImageLayout(enc, &val->initialLayout); + vn_encode_VkImageLayout(enc, &val->finalLayout); +} + +static inline void +vn_encode_VkAttachmentDescription2(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 }); + vn_encode_VkAttachmentDescription2_pnext(enc, val->pNext); + vn_encode_VkAttachmentDescription2_self(enc, val); +} + +/* struct VkAttachmentReferenceStencilLayout chain */ + +static inline size_t +vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkImageLayout(&val->stencilLayout); + return size; +} + +static inline size_t +vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(val->pNext); + size += vn_sizeof_VkAttachmentReferenceStencilLayout_self(val); + + return size; +} + +static inline void +vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkImageLayout(enc, &val->stencilLayout); +} + +static inline void +vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT }); + vn_encode_VkAttachmentReferenceStencilLayout_pnext(enc, val->pNext); + vn_encode_VkAttachmentReferenceStencilLayout_self(enc, val); +} + +/* struct VkAttachmentReference2 chain */ + +static inline size_t +vn_sizeof_VkAttachmentReference2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkAttachmentReference2_pnext(pnext->pNext); + size += vn_sizeof_VkAttachmentReferenceStencilLayout_self((const VkAttachmentReferenceStencilLayout *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->attachment); + size += vn_sizeof_VkImageLayout(&val->layout); + size += vn_sizeof_VkFlags(&val->aspectMask); + return size; +} + +static inline size_t +vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkAttachmentReference2_pnext(val->pNext); + size += vn_sizeof_VkAttachmentReference2_self(val); + + return size; +} + +static inline void +vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkAttachmentReference2_pnext(enc, pnext->pNext); + vn_encode_VkAttachmentReferenceStencilLayout_self(enc, (const VkAttachmentReferenceStencilLayout *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->attachment); + vn_encode_VkImageLayout(enc, &val->layout); + vn_encode_VkFlags(enc, &val->aspectMask); +} + +static inline void +vn_encode_VkAttachmentReference2(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 }); + vn_encode_VkAttachmentReference2_pnext(enc, val->pNext); + vn_encode_VkAttachmentReference2_self(enc, val); +} + +/* struct VkSubpassDescriptionDepthStencilResolve chain */ + +static inline size_t +vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkResolveModeFlagBits(&val->depthResolveMode); + size += vn_sizeof_VkResolveModeFlagBits(&val->stencilResolveMode); + size += vn_sizeof_simple_pointer(val->pDepthStencilResolveAttachment); + if (val->pDepthStencilResolveAttachment) + size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilResolveAttachment); + return size; +} + +static inline size_t +vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(val->pNext); + size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(val); + + return size; +} + +static inline void +vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkResolveModeFlagBits(enc, &val->depthResolveMode); + vn_encode_VkResolveModeFlagBits(enc, &val->stencilResolveMode); + if (vn_encode_simple_pointer(enc, val->pDepthStencilResolveAttachment)) + vn_encode_VkAttachmentReference2(enc, val->pDepthStencilResolveAttachment); +} + +static inline void +vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE }); + vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(enc, val->pNext); + vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, val); +} + +/* struct VkSubpassDescription2 chain */ + +static inline size_t +vn_sizeof_VkSubpassDescription2_pnext(const void *val) +{ + const VkBaseInStructure *pnext = val; + size_t size = 0; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + size += vn_sizeof_simple_pointer(pnext); + size += vn_sizeof_VkStructureType(&pnext->sType); + size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext); + size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self((const VkSubpassDescriptionDepthStencilResolve *)pnext); + return size; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint); + size += vn_sizeof_uint32_t(&val->viewMask); + size += vn_sizeof_uint32_t(&val->inputAttachmentCount); + if (val->pInputAttachments) { + size += vn_sizeof_array_size(val->inputAttachmentCount); + for (uint32_t i = 0; i < val->inputAttachmentCount; i++) + size += vn_sizeof_VkAttachmentReference2(&val->pInputAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->colorAttachmentCount); + if (val->pColorAttachments) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + size += vn_sizeof_VkAttachmentReference2(&val->pColorAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + if (val->pResolveAttachments) { + size += vn_sizeof_array_size(val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + size += vn_sizeof_VkAttachmentReference2(&val->pResolveAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment); + if (val->pDepthStencilAttachment) + size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilAttachment); + size += vn_sizeof_uint32_t(&val->preserveAttachmentCount); + if (val->pPreserveAttachments) { + size += vn_sizeof_array_size(val->preserveAttachmentCount); + size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubpassDescription2_pnext(val->pNext); + size += vn_sizeof_VkSubpassDescription2_self(val); + + return size; +} + +static inline void +vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + const VkBaseInStructure *pnext = val; + + while (pnext) { + switch ((int32_t)pnext->sType) { + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + vn_encode_simple_pointer(enc, pnext); + vn_encode_VkStructureType(enc, &pnext->sType); + vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext); + vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, (const VkSubpassDescriptionDepthStencilResolve *)pnext); + return; + default: + /* ignore unknown/unsupported struct */ + break; + } + pnext = pnext->pNext; + } + + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint); + vn_encode_uint32_t(enc, &val->viewMask); + vn_encode_uint32_t(enc, &val->inputAttachmentCount); + if (val->pInputAttachments) { + vn_encode_array_size(enc, val->inputAttachmentCount); + for (uint32_t i = 0; i < val->inputAttachmentCount; i++) + vn_encode_VkAttachmentReference2(enc, &val->pInputAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->colorAttachmentCount); + if (val->pColorAttachments) { + vn_encode_array_size(enc, val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + vn_encode_VkAttachmentReference2(enc, &val->pColorAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (val->pResolveAttachments) { + vn_encode_array_size(enc, val->colorAttachmentCount); + for (uint32_t i = 0; i < val->colorAttachmentCount; i++) + vn_encode_VkAttachmentReference2(enc, &val->pResolveAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment)) + vn_encode_VkAttachmentReference2(enc, val->pDepthStencilAttachment); + vn_encode_uint32_t(enc, &val->preserveAttachmentCount); + if (val->pPreserveAttachments) { + vn_encode_array_size(enc, val->preserveAttachmentCount); + vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 }); + vn_encode_VkSubpassDescription2_pnext(enc, val->pNext); + vn_encode_VkSubpassDescription2_self(enc, val); +} + +/* struct VkSubpassDependency2 chain */ + +static inline size_t +vn_sizeof_VkSubpassDependency2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint32_t(&val->srcSubpass); + size += vn_sizeof_uint32_t(&val->dstSubpass); + size += vn_sizeof_VkFlags(&val->srcStageMask); + size += vn_sizeof_VkFlags(&val->dstStageMask); + size += vn_sizeof_VkFlags(&val->srcAccessMask); + size += vn_sizeof_VkFlags(&val->dstAccessMask); + size += vn_sizeof_VkFlags(&val->dependencyFlags); + size += vn_sizeof_int32_t(&val->viewOffset); + return size; +} + +static inline size_t +vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubpassDependency2_pnext(val->pNext); + size += vn_sizeof_VkSubpassDependency2_self(val); + + return size; +} + +static inline void +vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_uint32_t(enc, &val->srcSubpass); + vn_encode_uint32_t(enc, &val->dstSubpass); + vn_encode_VkFlags(enc, &val->srcStageMask); + vn_encode_VkFlags(enc, &val->dstStageMask); + vn_encode_VkFlags(enc, &val->srcAccessMask); + vn_encode_VkFlags(enc, &val->dstAccessMask); + vn_encode_VkFlags(enc, &val->dependencyFlags); + vn_encode_int32_t(enc, &val->viewOffset); +} + +static inline void +vn_encode_VkSubpassDependency2(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 }); + vn_encode_VkSubpassDependency2_pnext(enc, val->pNext); + vn_encode_VkSubpassDependency2_self(enc, val); +} + +/* struct VkRenderPassCreateInfo2 chain */ + +static inline size_t +vn_sizeof_VkRenderPassCreateInfo2_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->attachmentCount); + if (val->pAttachments) { + size += vn_sizeof_array_size(val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + size += vn_sizeof_VkAttachmentDescription2(&val->pAttachments[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->subpassCount); + if (val->pSubpasses) { + size += vn_sizeof_array_size(val->subpassCount); + for (uint32_t i = 0; i < val->subpassCount; i++) + size += vn_sizeof_VkSubpassDescription2(&val->pSubpasses[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->dependencyCount); + if (val->pDependencies) { + size += vn_sizeof_array_size(val->dependencyCount); + for (uint32_t i = 0; i < val->dependencyCount; i++) + size += vn_sizeof_VkSubpassDependency2(&val->pDependencies[i]); + } else { + size += vn_sizeof_array_size(0); + } + size += vn_sizeof_uint32_t(&val->correlatedViewMaskCount); + if (val->pCorrelatedViewMasks) { + size += vn_sizeof_array_size(val->correlatedViewMaskCount); + size += vn_sizeof_uint32_t_array(val->pCorrelatedViewMasks, val->correlatedViewMaskCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRenderPassCreateInfo2_pnext(val->pNext); + size += vn_sizeof_VkRenderPassCreateInfo2_self(val); + + return size; +} + +static inline void +vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->attachmentCount); + if (val->pAttachments) { + vn_encode_array_size(enc, val->attachmentCount); + for (uint32_t i = 0; i < val->attachmentCount; i++) + vn_encode_VkAttachmentDescription2(enc, &val->pAttachments[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->subpassCount); + if (val->pSubpasses) { + vn_encode_array_size(enc, val->subpassCount); + for (uint32_t i = 0; i < val->subpassCount; i++) + vn_encode_VkSubpassDescription2(enc, &val->pSubpasses[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->dependencyCount); + if (val->pDependencies) { + vn_encode_array_size(enc, val->dependencyCount); + for (uint32_t i = 0; i < val->dependencyCount; i++) + vn_encode_VkSubpassDependency2(enc, &val->pDependencies[i]); + } else { + vn_encode_array_size(enc, 0); + } + vn_encode_uint32_t(enc, &val->correlatedViewMaskCount); + if (val->pCorrelatedViewMasks) { + vn_encode_array_size(enc, val->correlatedViewMaskCount); + vn_encode_uint32_t_array(enc, val->pCorrelatedViewMasks, val->correlatedViewMaskCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 }); + vn_encode_VkRenderPassCreateInfo2_pnext(enc, val->pNext); + vn_encode_VkRenderPassCreateInfo2_self(enc, val); +} + +/* struct VkSubpassBeginInfo chain */ + +static inline size_t +vn_sizeof_VkSubpassBeginInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubpassBeginInfo_self(const VkSubpassBeginInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSubpassContents(&val->contents); + return size; +} + +static inline size_t +vn_sizeof_VkSubpassBeginInfo(const VkSubpassBeginInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubpassBeginInfo_pnext(val->pNext); + size += vn_sizeof_VkSubpassBeginInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSubpassBeginInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubpassBeginInfo_self(struct vn_cs_encoder *enc, const VkSubpassBeginInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSubpassContents(enc, &val->contents); +} + +static inline void +vn_encode_VkSubpassBeginInfo(struct vn_cs_encoder *enc, const VkSubpassBeginInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO }); + vn_encode_VkSubpassBeginInfo_pnext(enc, val->pNext); + vn_encode_VkSubpassBeginInfo_self(enc, val); +} + +/* struct VkSubpassEndInfo chain */ + +static inline size_t +vn_sizeof_VkSubpassEndInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSubpassEndInfo_self(const VkSubpassEndInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + return size; +} + +static inline size_t +vn_sizeof_VkSubpassEndInfo(const VkSubpassEndInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSubpassEndInfo_pnext(val->pNext); + size += vn_sizeof_VkSubpassEndInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSubpassEndInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSubpassEndInfo_self(struct vn_cs_encoder *enc, const VkSubpassEndInfo *val) +{ + /* skip val->{sType,pNext} */ +} + +static inline void +vn_encode_VkSubpassEndInfo(struct vn_cs_encoder *enc, const VkSubpassEndInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_END_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_END_INFO }); + vn_encode_VkSubpassEndInfo_pnext(enc, val->pNext); + vn_encode_VkSubpassEndInfo_self(enc, val); +} + +/* struct VkSemaphoreWaitInfo chain */ + +static inline size_t +vn_sizeof_VkSemaphoreWaitInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSemaphoreWaitInfo_self(const VkSemaphoreWaitInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->semaphoreCount); + if (val->pSemaphores) { + size += vn_sizeof_array_size(val->semaphoreCount); + for (uint32_t i = 0; i < val->semaphoreCount; i++) + size += vn_sizeof_VkSemaphore(&val->pSemaphores[i]); + } else { + size += vn_sizeof_array_size(0); + } + if (val->pValues) { + size += vn_sizeof_array_size(val->semaphoreCount); + size += vn_sizeof_uint64_t_array(val->pValues, val->semaphoreCount); + } else { + size += vn_sizeof_array_size(0); + } + return size; +} + +static inline size_t +vn_sizeof_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSemaphoreWaitInfo_pnext(val->pNext); + size += vn_sizeof_VkSemaphoreWaitInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSemaphoreWaitInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSemaphoreWaitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->semaphoreCount); + if (val->pSemaphores) { + vn_encode_array_size(enc, val->semaphoreCount); + for (uint32_t i = 0; i < val->semaphoreCount; i++) + vn_encode_VkSemaphore(enc, &val->pSemaphores[i]); + } else { + vn_encode_array_size(enc, 0); + } + if (val->pValues) { + vn_encode_array_size(enc, val->semaphoreCount); + vn_encode_uint64_t_array(enc, val->pValues, val->semaphoreCount); + } else { + vn_encode_array_size(enc, 0); + } +} + +static inline void +vn_encode_VkSemaphoreWaitInfo(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO }); + vn_encode_VkSemaphoreWaitInfo_pnext(enc, val->pNext); + vn_encode_VkSemaphoreWaitInfo_self(enc, val); +} + +/* struct VkSemaphoreSignalInfo chain */ + +static inline size_t +vn_sizeof_VkSemaphoreSignalInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkSemaphoreSignalInfo_self(const VkSemaphoreSignalInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkSemaphore(&val->semaphore); + size += vn_sizeof_uint64_t(&val->value); + return size; +} + +static inline size_t +vn_sizeof_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkSemaphoreSignalInfo_pnext(val->pNext); + size += vn_sizeof_VkSemaphoreSignalInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkSemaphoreSignalInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkSemaphoreSignalInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkSemaphore(enc, &val->semaphore); + vn_encode_uint64_t(enc, &val->value); +} + +static inline void +vn_encode_VkSemaphoreSignalInfo(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO }); + vn_encode_VkSemaphoreSignalInfo_pnext(enc, val->pNext); + vn_encode_VkSemaphoreSignalInfo_self(enc, val); +} + +static inline void +vn_decode_VkSemaphoreSignalInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkSemaphoreSignalInfo_self(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkSemaphore(dec, &val->semaphore); + vn_decode_uint64_t(dec, &val->value); +} + +static inline void +vn_decode_VkSemaphoreSignalInfo(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO); + + assert(val->sType == stype); + vn_decode_VkSemaphoreSignalInfo_pnext(dec, val->pNext); + vn_decode_VkSemaphoreSignalInfo_self(dec, val); +} + +/* struct VkImageDrmFormatModifierPropertiesEXT chain */ + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(const VkImageDrmFormatModifierPropertiesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_uint64_t(&val->drmFormatModifier); + return size; +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(val->pNext); + size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(val); + + return size; +} + +static inline void +vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_uint64_t(dec, &val->drmFormatModifier); +} + +static inline void +vn_decode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT); + + assert(val->sType == stype); + vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(dec, val->pNext); + vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(dec, val); +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(const VkImageDrmFormatModifierPropertiesEXT *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + /* skip val->drmFormatModifier */ + return size; +} + +static inline size_t +vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(const VkImageDrmFormatModifierPropertiesEXT *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(val->pNext); + size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(val); + + return size; +} + +static inline void +vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val) +{ + /* skip val->{sType,pNext} */ + /* skip val->drmFormatModifier */ +} + +static inline void +vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT }); + vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(enc, val->pNext); + vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(enc, val); +} + +/* struct VkBufferDeviceAddressInfo chain */ + +static inline size_t +vn_sizeof_VkBufferDeviceAddressInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkBufferDeviceAddressInfo_self(const VkBufferDeviceAddressInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkBuffer(&val->buffer); + return size; +} + +static inline size_t +vn_sizeof_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkBufferDeviceAddressInfo_pnext(val->pNext); + size += vn_sizeof_VkBufferDeviceAddressInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkBufferDeviceAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkBufferDeviceAddressInfo_self(struct vn_cs_encoder *enc, const VkBufferDeviceAddressInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkBuffer(enc, &val->buffer); +} + +static inline void +vn_encode_VkBufferDeviceAddressInfo(struct vn_cs_encoder *enc, const VkBufferDeviceAddressInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO }); + vn_encode_VkBufferDeviceAddressInfo_pnext(enc, val->pNext); + vn_encode_VkBufferDeviceAddressInfo_self(enc, val); +} + +static inline void +vn_decode_VkBufferDeviceAddressInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkBufferDeviceAddressInfo_self(struct vn_cs_decoder *dec, VkBufferDeviceAddressInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkBuffer(dec, &val->buffer); +} + +static inline void +vn_decode_VkBufferDeviceAddressInfo(struct vn_cs_decoder *dec, VkBufferDeviceAddressInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO); + + assert(val->sType == stype); + vn_decode_VkBufferDeviceAddressInfo_pnext(dec, val->pNext); + vn_decode_VkBufferDeviceAddressInfo_self(dec, val); +} + +/* struct VkDeviceMemoryOpaqueCaptureAddressInfo chain */ + +static inline size_t +vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(const VkDeviceMemoryOpaqueCaptureAddressInfo *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkDeviceMemory(&val->memory); + return size; +} + +static inline size_t +vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(val->pNext); + size += vn_sizeof_VkDeviceMemoryOpaqueCaptureAddressInfo_self(val); + + return size; +} + +static inline void +vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkDeviceMemory(enc, &val->memory); +} + +static inline void +vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_encoder *enc, const VkDeviceMemoryOpaqueCaptureAddressInfo *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO }); + vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(enc, val->pNext); + vn_encode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(enc, val); +} + +static inline void +vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(struct vn_cs_decoder *dec, const void *val) +{ + /* no known/supported struct */ + if (vn_decode_simple_pointer(dec)) + assert(false); +} + +static inline void +vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(struct vn_cs_decoder *dec, VkDeviceMemoryOpaqueCaptureAddressInfo *val) +{ + /* skip val->{sType,pNext} */ + vn_decode_VkDeviceMemory(dec, &val->memory); +} + +static inline void +vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo(struct vn_cs_decoder *dec, VkDeviceMemoryOpaqueCaptureAddressInfo *val) +{ + VkStructureType stype; + vn_decode_VkStructureType(dec, &stype); + assert(stype == VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO); + + assert(val->sType == stype); + vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_pnext(dec, val->pNext); + vn_decode_VkDeviceMemoryOpaqueCaptureAddressInfo_self(dec, val); +} + +/* struct VkCommandStreamDescriptionMESA */ + +static inline size_t +vn_sizeof_VkCommandStreamDescriptionMESA(const VkCommandStreamDescriptionMESA *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->resourceId); + size += vn_sizeof_size_t(&val->offset); + size += vn_sizeof_size_t(&val->size); + return size; +} + +static inline void +vn_encode_VkCommandStreamDescriptionMESA(struct vn_cs_encoder *enc, const VkCommandStreamDescriptionMESA *val) +{ + vn_encode_uint32_t(enc, &val->resourceId); + vn_encode_size_t(enc, &val->offset); + vn_encode_size_t(enc, &val->size); +} + +/* struct VkCommandStreamDependencyMESA */ + +static inline size_t +vn_sizeof_VkCommandStreamDependencyMESA(const VkCommandStreamDependencyMESA *val) +{ + size_t size = 0; + size += vn_sizeof_uint32_t(&val->srcCommandStream); + size += vn_sizeof_uint32_t(&val->dstCommandStream); + return size; +} + +static inline void +vn_encode_VkCommandStreamDependencyMESA(struct vn_cs_encoder *enc, const VkCommandStreamDependencyMESA *val) +{ + vn_encode_uint32_t(enc, &val->srcCommandStream); + vn_encode_uint32_t(enc, &val->dstCommandStream); +} + +/* struct VkRingCreateInfoMESA chain */ + +static inline size_t +vn_sizeof_VkRingCreateInfoMESA_pnext(const void *val) +{ + /* no known/supported struct */ + return vn_sizeof_simple_pointer(NULL); +} + +static inline size_t +vn_sizeof_VkRingCreateInfoMESA_self(const VkRingCreateInfoMESA *val) +{ + size_t size = 0; + /* skip val->{sType,pNext} */ + size += vn_sizeof_VkFlags(&val->flags); + size += vn_sizeof_uint32_t(&val->resourceId); + size += vn_sizeof_size_t(&val->offset); + size += vn_sizeof_size_t(&val->size); + size += vn_sizeof_uint64_t(&val->idleTimeout); + size += vn_sizeof_size_t(&val->headOffset); + size += vn_sizeof_size_t(&val->tailOffset); + size += vn_sizeof_size_t(&val->statusOffset); + size += vn_sizeof_size_t(&val->bufferOffset); + size += vn_sizeof_size_t(&val->bufferSize); + size += vn_sizeof_size_t(&val->extraOffset); + size += vn_sizeof_size_t(&val->extraSize); + return size; +} + +static inline size_t +vn_sizeof_VkRingCreateInfoMESA(const VkRingCreateInfoMESA *val) +{ + size_t size = 0; + + size += vn_sizeof_VkStructureType(&val->sType); + size += vn_sizeof_VkRingCreateInfoMESA_pnext(val->pNext); + size += vn_sizeof_VkRingCreateInfoMESA_self(val); + + return size; +} + +static inline void +vn_encode_VkRingCreateInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val) +{ + /* no known/supported struct */ + vn_encode_simple_pointer(enc, NULL); +} + +static inline void +vn_encode_VkRingCreateInfoMESA_self(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val) +{ + /* skip val->{sType,pNext} */ + vn_encode_VkFlags(enc, &val->flags); + vn_encode_uint32_t(enc, &val->resourceId); + vn_encode_size_t(enc, &val->offset); + vn_encode_size_t(enc, &val->size); + vn_encode_uint64_t(enc, &val->idleTimeout); + vn_encode_size_t(enc, &val->headOffset); + vn_encode_size_t(enc, &val->tailOffset); + vn_encode_size_t(enc, &val->statusOffset); + vn_encode_size_t(enc, &val->bufferOffset); + vn_encode_size_t(enc, &val->bufferSize); + vn_encode_size_t(enc, &val->extraOffset); + vn_encode_size_t(enc, &val->extraSize); +} + +static inline void +vn_encode_VkRingCreateInfoMESA(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val) +{ + assert(val->sType == VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA); + vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA }); + vn_encode_VkRingCreateInfoMESA_pnext(enc, val->pNext); + vn_encode_VkRingCreateInfoMESA_self(enc, val); +} + +/* + * Helpers for manual serialization + */ + +#endif /* VN_PROTOCOL_DRIVER_STRUCTS_H */ diff --git a/src/virtio/venus-protocol/vn_protocol_driver_types.h b/src/virtio/venus-protocol/vn_protocol_driver_types.h new file mode 100644 index 00000000000..5ce28370b0b --- /dev/null +++ b/src/virtio/venus-protocol/vn_protocol_driver_types.h @@ -0,0 +1,2791 @@ +/* This file is generated by venus-protocol git-72189394. */ + +/* + * Copyright 2020 Google LLC + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_DRIVER_TYPES_H +#define VN_PROTOCOL_DRIVER_TYPES_H + +#include "vn_protocol_driver_defines.h" + +/* uint64_t */ + +static inline size_t +vn_sizeof_uint64_t(const uint64_t *val) +{ + assert(sizeof(*val) == 8); + return 8; +} + +static inline void +vn_encode_uint64_t(struct vn_cs_encoder *enc, const uint64_t *val) +{ + vn_encode(enc, 8, val, sizeof(*val)); +} + +static inline void +vn_decode_uint64_t(struct vn_cs_decoder *dec, uint64_t *val) +{ + vn_decode(dec, 8, val, sizeof(*val)); +} + +static inline size_t +vn_sizeof_uint64_t_array(const uint64_t *val, uint32_t count) +{ + assert(sizeof(*val) == 8); + const size_t size = sizeof(*val) * count; + assert(size >= count); + return size; +} + +static inline void +vn_encode_uint64_t_array(struct vn_cs_encoder *enc, const uint64_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_encode(enc, size, val, size); +} + +static inline void +vn_decode_uint64_t_array(struct vn_cs_decoder *dec, uint64_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_decode(dec, size, val, size); +} + +/* int32_t */ + +static inline size_t +vn_sizeof_int32_t(const int32_t *val) +{ + assert(sizeof(*val) == 4); + return 4; +} + +static inline void +vn_encode_int32_t(struct vn_cs_encoder *enc, const int32_t *val) +{ + vn_encode(enc, 4, val, sizeof(*val)); +} + +static inline void +vn_decode_int32_t(struct vn_cs_decoder *dec, int32_t *val) +{ + vn_decode(dec, 4, val, sizeof(*val)); +} + +static inline size_t +vn_sizeof_int32_t_array(const int32_t *val, uint32_t count) +{ + assert(sizeof(*val) == 4); + const size_t size = sizeof(*val) * count; + assert(size >= count); + return size; +} + +static inline void +vn_encode_int32_t_array(struct vn_cs_encoder *enc, const int32_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_encode(enc, size, val, size); +} + +static inline void +vn_decode_int32_t_array(struct vn_cs_decoder *dec, int32_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_decode(dec, size, val, size); +} + +/* enum VkStructureType */ + +static inline size_t +vn_sizeof_VkStructureType(const VkStructureType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkStructureType(struct vn_cs_encoder *enc, const VkStructureType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkStructureType(struct vn_cs_decoder *dec, VkStructureType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* size_t */ + +static inline size_t +vn_sizeof_size_t(const size_t *val) +{ + return vn_sizeof_uint64_t(&(uint64_t){ *val }); +} + +static inline void +vn_encode_size_t(struct vn_cs_encoder *enc, const size_t *val) +{ + const uint64_t tmp = *val; + vn_encode_uint64_t(enc, &tmp); +} + +static inline void +vn_decode_size_t(struct vn_cs_decoder *dec, size_t *val) +{ + uint64_t tmp; + vn_decode_uint64_t(dec, &tmp); + *val = tmp; +} + +static inline size_t +vn_sizeof_size_t_array(const size_t *val, uint32_t count) +{ + return vn_sizeof_size_t(val) * count; +} + +static inline void +vn_encode_size_t_array(struct vn_cs_encoder *enc, const size_t *val, uint32_t count) +{ + if (sizeof(size_t) == sizeof(uint64_t)) { + vn_encode_uint64_t_array(enc, (const uint64_t *)val, count); + } else { + for (uint32_t i = 0; i < count; i++) + vn_encode_size_t(enc, &val[i]); + } +} + +static inline void +vn_decode_size_t_array(struct vn_cs_decoder *dec, size_t *val, uint32_t count) +{ + if (sizeof(size_t) == sizeof(uint64_t)) { + vn_decode_uint64_t_array(dec, (uint64_t *)val, count); + } else { + for (uint32_t i = 0; i < count; i++) + vn_decode_size_t(dec, &val[i]); + } +} + +/* opaque blob */ + +static inline size_t +vn_sizeof_blob_array(const void *val, size_t size) +{ + return (size + 3) & ~3; +} + +static inline void +vn_encode_blob_array(struct vn_cs_encoder *enc, const void *val, size_t size) +{ + vn_encode(enc, (size + 3) & ~3, val, size); +} + +static inline void +vn_decode_blob_array(struct vn_cs_decoder *dec, void *val, size_t size) +{ + vn_decode(dec, (size + 3) & ~3, val, size); +} + +/* array size (uint64_t) */ + +static inline size_t +vn_sizeof_array_size(uint64_t size) +{ + return vn_sizeof_uint64_t(&size); +} + +static inline void +vn_encode_array_size(struct vn_cs_encoder *enc, uint64_t size) +{ + vn_encode_uint64_t(enc, &size); +} + +static inline uint64_t +vn_decode_array_size(struct vn_cs_decoder *dec, uint64_t max_size) +{ + uint64_t size; + vn_decode_uint64_t(dec, &size); + if (size > max_size) { + vn_cs_decoder_set_fatal(dec); + size = 0; + } + return size; +} + +static inline uint64_t +vn_peek_array_size(struct vn_cs_decoder *dec) +{ + uint64_t size; + vn_cs_decoder_peek(dec, sizeof(size), &size, sizeof(size)); + return size; +} + +/* non-array pointer */ + +static inline size_t +vn_sizeof_simple_pointer(const void *val) +{ + return vn_sizeof_array_size(val ? 1 : 0); +} + +static inline bool +vn_encode_simple_pointer(struct vn_cs_encoder *enc, const void *val) +{ + vn_encode_array_size(enc, val ? 1 : 0); + return val; +} + +static inline bool +vn_decode_simple_pointer(struct vn_cs_decoder *dec) +{ + return vn_decode_array_size(dec, 1); +} + +/* uint32_t */ + +static inline size_t +vn_sizeof_uint32_t(const uint32_t *val) +{ + assert(sizeof(*val) == 4); + return 4; +} + +static inline void +vn_encode_uint32_t(struct vn_cs_encoder *enc, const uint32_t *val) +{ + vn_encode(enc, 4, val, sizeof(*val)); +} + +static inline void +vn_decode_uint32_t(struct vn_cs_decoder *dec, uint32_t *val) +{ + vn_decode(dec, 4, val, sizeof(*val)); +} + +static inline size_t +vn_sizeof_uint32_t_array(const uint32_t *val, uint32_t count) +{ + assert(sizeof(*val) == 4); + const size_t size = sizeof(*val) * count; + assert(size >= count); + return size; +} + +static inline void +vn_encode_uint32_t_array(struct vn_cs_encoder *enc, const uint32_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_encode(enc, size, val, size); +} + +static inline void +vn_decode_uint32_t_array(struct vn_cs_decoder *dec, uint32_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_decode(dec, size, val, size); +} + +/* float */ + +static inline size_t +vn_sizeof_float(const float *val) +{ + assert(sizeof(*val) == 4); + return 4; +} + +static inline void +vn_encode_float(struct vn_cs_encoder *enc, const float *val) +{ + vn_encode(enc, 4, val, sizeof(*val)); +} + +static inline void +vn_decode_float(struct vn_cs_decoder *dec, float *val) +{ + vn_decode(dec, 4, val, sizeof(*val)); +} + +static inline size_t +vn_sizeof_float_array(const float *val, uint32_t count) +{ + assert(sizeof(*val) == 4); + const size_t size = sizeof(*val) * count; + assert(size >= count); + return size; +} + +static inline void +vn_encode_float_array(struct vn_cs_encoder *enc, const float *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_encode(enc, size, val, size); +} + +static inline void +vn_decode_float_array(struct vn_cs_decoder *dec, float *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_decode(dec, size, val, size); +} + +/* uint8_t */ + +static inline size_t +vn_sizeof_uint8_t(const uint8_t *val) +{ + assert(sizeof(*val) == 1); + return 4; +} + +static inline void +vn_encode_uint8_t(struct vn_cs_encoder *enc, const uint8_t *val) +{ + vn_encode(enc, 4, val, sizeof(*val)); +} + +static inline void +vn_decode_uint8_t(struct vn_cs_decoder *dec, uint8_t *val) +{ + vn_decode(dec, 4, val, sizeof(*val)); +} + +static inline size_t +vn_sizeof_uint8_t_array(const uint8_t *val, uint32_t count) +{ + assert(sizeof(*val) == 1); + const size_t size = sizeof(*val) * count; + assert(size >= count); + return (size + 3) & ~3; +} + +static inline void +vn_encode_uint8_t_array(struct vn_cs_encoder *enc, const uint8_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_encode(enc, (size + 3) & ~3, val, size); +} + +static inline void +vn_decode_uint8_t_array(struct vn_cs_decoder *dec, uint8_t *val, uint32_t count) +{ + const size_t size = sizeof(*val) * count; + assert(size >= count); + vn_decode(dec, (size + 3) & ~3, val, size); +} + +/* typedef uint32_t VkSampleMask */ + +static inline size_t +vn_sizeof_VkSampleMask(const VkSampleMask *val) +{ + return vn_sizeof_uint32_t(val); +} + +static inline void +vn_encode_VkSampleMask(struct vn_cs_encoder *enc, const VkSampleMask *val) +{ + vn_encode_uint32_t(enc, val); +} + +static inline void +vn_decode_VkSampleMask(struct vn_cs_decoder *dec, VkSampleMask *val) +{ + vn_decode_uint32_t(dec, val); +} + +static inline size_t +vn_sizeof_VkSampleMask_array(const VkSampleMask *val, uint32_t count) +{ + return vn_sizeof_uint32_t_array(val, count); +} + +static inline void +vn_encode_VkSampleMask_array(struct vn_cs_encoder *enc, const VkSampleMask *val, uint32_t count) +{ + vn_encode_uint32_t_array(enc, val, count); +} + +static inline void +vn_decode_VkSampleMask_array(struct vn_cs_decoder *dec, VkSampleMask *val, uint32_t count) +{ + vn_decode_uint32_t_array(dec, val, count); +} + +/* typedef uint32_t VkBool32 */ + +static inline size_t +vn_sizeof_VkBool32(const VkBool32 *val) +{ + return vn_sizeof_uint32_t(val); +} + +static inline void +vn_encode_VkBool32(struct vn_cs_encoder *enc, const VkBool32 *val) +{ + vn_encode_uint32_t(enc, val); +} + +static inline void +vn_decode_VkBool32(struct vn_cs_decoder *dec, VkBool32 *val) +{ + vn_decode_uint32_t(dec, val); +} + +static inline size_t +vn_sizeof_VkBool32_array(const VkBool32 *val, uint32_t count) +{ + return vn_sizeof_uint32_t_array(val, count); +} + +static inline void +vn_encode_VkBool32_array(struct vn_cs_encoder *enc, const VkBool32 *val, uint32_t count) +{ + vn_encode_uint32_t_array(enc, val, count); +} + +static inline void +vn_decode_VkBool32_array(struct vn_cs_decoder *dec, VkBool32 *val, uint32_t count) +{ + vn_decode_uint32_t_array(dec, val, count); +} + +/* typedef uint32_t VkFlags */ + +static inline size_t +vn_sizeof_VkFlags(const VkFlags *val) +{ + return vn_sizeof_uint32_t(val); +} + +static inline void +vn_encode_VkFlags(struct vn_cs_encoder *enc, const VkFlags *val) +{ + vn_encode_uint32_t(enc, val); +} + +static inline void +vn_decode_VkFlags(struct vn_cs_decoder *dec, VkFlags *val) +{ + vn_decode_uint32_t(dec, val); +} + +static inline size_t +vn_sizeof_VkFlags_array(const VkFlags *val, uint32_t count) +{ + return vn_sizeof_uint32_t_array(val, count); +} + +static inline void +vn_encode_VkFlags_array(struct vn_cs_encoder *enc, const VkFlags *val, uint32_t count) +{ + vn_encode_uint32_t_array(enc, val, count); +} + +static inline void +vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count) +{ + vn_decode_uint32_t_array(dec, val, count); +} + +/* typedef uint64_t VkDeviceSize */ + +static inline size_t +vn_sizeof_VkDeviceSize(const VkDeviceSize *val) +{ + return vn_sizeof_uint64_t(val); +} + +static inline void +vn_encode_VkDeviceSize(struct vn_cs_encoder *enc, const VkDeviceSize *val) +{ + vn_encode_uint64_t(enc, val); +} + +static inline void +vn_decode_VkDeviceSize(struct vn_cs_decoder *dec, VkDeviceSize *val) +{ + vn_decode_uint64_t(dec, val); +} + +static inline size_t +vn_sizeof_VkDeviceSize_array(const VkDeviceSize *val, uint32_t count) +{ + return vn_sizeof_uint64_t_array(val, count); +} + +static inline void +vn_encode_VkDeviceSize_array(struct vn_cs_encoder *enc, const VkDeviceSize *val, uint32_t count) +{ + vn_encode_uint64_t_array(enc, val, count); +} + +static inline void +vn_decode_VkDeviceSize_array(struct vn_cs_decoder *dec, VkDeviceSize *val, uint32_t count) +{ + vn_decode_uint64_t_array(dec, val, count); +} + +/* typedef uint64_t VkDeviceAddress */ + +static inline size_t +vn_sizeof_VkDeviceAddress(const VkDeviceAddress *val) +{ + return vn_sizeof_uint64_t(val); +} + +static inline void +vn_encode_VkDeviceAddress(struct vn_cs_encoder *enc, const VkDeviceAddress *val) +{ + vn_encode_uint64_t(enc, val); +} + +static inline void +vn_decode_VkDeviceAddress(struct vn_cs_decoder *dec, VkDeviceAddress *val) +{ + vn_decode_uint64_t(dec, val); +} + +static inline size_t +vn_sizeof_VkDeviceAddress_array(const VkDeviceAddress *val, uint32_t count) +{ + return vn_sizeof_uint64_t_array(val, count); +} + +static inline void +vn_encode_VkDeviceAddress_array(struct vn_cs_encoder *enc, const VkDeviceAddress *val, uint32_t count) +{ + vn_encode_uint64_t_array(enc, val, count); +} + +static inline void +vn_decode_VkDeviceAddress_array(struct vn_cs_decoder *dec, VkDeviceAddress *val, uint32_t count) +{ + vn_decode_uint64_t_array(dec, val, count); +} + +/* enum VkFramebufferCreateFlagBits */ + +static inline size_t +vn_sizeof_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFramebufferCreateFlagBits(struct vn_cs_encoder *enc, const VkFramebufferCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFramebufferCreateFlagBits(struct vn_cs_decoder *dec, VkFramebufferCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkRenderPassCreateFlagBits */ + +static inline size_t +vn_sizeof_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkRenderPassCreateFlagBits(struct vn_cs_encoder *enc, const VkRenderPassCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkRenderPassCreateFlagBits(struct vn_cs_decoder *dec, VkRenderPassCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSamplerCreateFlagBits */ + +static inline size_t +vn_sizeof_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSamplerCreateFlagBits(struct vn_cs_encoder *enc, const VkSamplerCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSamplerCreateFlagBits(struct vn_cs_decoder *dec, VkSamplerCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineCacheCreateFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineCacheCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCacheCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCacheCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineShaderStageCreateFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDescriptorSetLayoutCreateFlagBits */ + +static inline size_t +vn_sizeof_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorSetLayoutCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDeviceQueueCreateFlagBits */ + +static inline size_t +vn_sizeof_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDeviceQueueCreateFlagBits(struct vn_cs_encoder *enc, const VkDeviceQueueCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDeviceQueueCreateFlagBits(struct vn_cs_decoder *dec, VkDeviceQueueCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkQueueFlagBits */ + +static inline size_t +vn_sizeof_VkQueueFlagBits(const VkQueueFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkQueueFlagBits(struct vn_cs_encoder *enc, const VkQueueFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkQueueFlagBits(struct vn_cs_decoder *dec, VkQueueFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkMemoryPropertyFlagBits */ + +static inline size_t +vn_sizeof_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkMemoryPropertyFlagBits(struct vn_cs_encoder *enc, const VkMemoryPropertyFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkMemoryPropertyFlagBits(struct vn_cs_decoder *dec, VkMemoryPropertyFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkMemoryHeapFlagBits */ + +static inline size_t +vn_sizeof_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkMemoryHeapFlagBits(struct vn_cs_encoder *enc, const VkMemoryHeapFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkMemoryHeapFlagBits(struct vn_cs_decoder *dec, VkMemoryHeapFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkAccessFlagBits */ + +static inline size_t +vn_sizeof_VkAccessFlagBits(const VkAccessFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkAccessFlagBits(struct vn_cs_encoder *enc, const VkAccessFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkAccessFlagBits(struct vn_cs_decoder *dec, VkAccessFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkBufferUsageFlagBits */ + +static inline size_t +vn_sizeof_VkBufferUsageFlagBits(const VkBufferUsageFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkBufferUsageFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkBufferUsageFlagBits(struct vn_cs_decoder *dec, VkBufferUsageFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkBufferCreateFlagBits */ + +static inline size_t +vn_sizeof_VkBufferCreateFlagBits(const VkBufferCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkBufferCreateFlagBits(struct vn_cs_encoder *enc, const VkBufferCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkBufferCreateFlagBits(struct vn_cs_decoder *dec, VkBufferCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkShaderStageFlagBits */ + +static inline size_t +vn_sizeof_VkShaderStageFlagBits(const VkShaderStageFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkShaderStageFlagBits(struct vn_cs_encoder *enc, const VkShaderStageFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkShaderStageFlagBits(struct vn_cs_decoder *dec, VkShaderStageFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageUsageFlagBits */ + +static inline size_t +vn_sizeof_VkImageUsageFlagBits(const VkImageUsageFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageUsageFlagBits(struct vn_cs_encoder *enc, const VkImageUsageFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageUsageFlagBits(struct vn_cs_decoder *dec, VkImageUsageFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageCreateFlagBits */ + +static inline size_t +vn_sizeof_VkImageCreateFlagBits(const VkImageCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageCreateFlagBits(struct vn_cs_encoder *enc, const VkImageCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageCreateFlagBits(struct vn_cs_decoder *dec, VkImageCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageViewCreateFlagBits */ + +static inline size_t +vn_sizeof_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageViewCreateFlagBits(struct vn_cs_encoder *enc, const VkImageViewCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageViewCreateFlagBits(struct vn_cs_decoder *dec, VkImageViewCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineCreateFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkColorComponentFlagBits */ + +static inline size_t +vn_sizeof_VkColorComponentFlagBits(const VkColorComponentFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkColorComponentFlagBits(struct vn_cs_encoder *enc, const VkColorComponentFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkColorComponentFlagBits(struct vn_cs_decoder *dec, VkColorComponentFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkFenceCreateFlagBits */ + +static inline size_t +vn_sizeof_VkFenceCreateFlagBits(const VkFenceCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFenceCreateFlagBits(struct vn_cs_encoder *enc, const VkFenceCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFenceCreateFlagBits(struct vn_cs_decoder *dec, VkFenceCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkFormatFeatureFlagBits */ + +static inline size_t +vn_sizeof_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFormatFeatureFlagBits(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFormatFeatureFlagBits(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkQueryControlFlagBits */ + +static inline size_t +vn_sizeof_VkQueryControlFlagBits(const VkQueryControlFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkQueryControlFlagBits(struct vn_cs_encoder *enc, const VkQueryControlFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkQueryControlFlagBits(struct vn_cs_decoder *dec, VkQueryControlFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkQueryResultFlagBits */ + +static inline size_t +vn_sizeof_VkQueryResultFlagBits(const VkQueryResultFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkQueryResultFlagBits(struct vn_cs_encoder *enc, const VkQueryResultFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkQueryResultFlagBits(struct vn_cs_decoder *dec, VkQueryResultFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandPoolCreateFlagBits */ + +static inline size_t +vn_sizeof_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandPoolCreateFlagBits(struct vn_cs_decoder *dec, VkCommandPoolCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandPoolResetFlagBits */ + +static inline size_t +vn_sizeof_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandPoolResetFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolResetFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandPoolResetFlagBits(struct vn_cs_decoder *dec, VkCommandPoolResetFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandBufferResetFlagBits */ + +static inline size_t +vn_sizeof_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandBufferResetFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferResetFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandBufferResetFlagBits(struct vn_cs_decoder *dec, VkCommandBufferResetFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandBufferUsageFlagBits */ + +static inline size_t +vn_sizeof_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferUsageFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandBufferUsageFlagBits(struct vn_cs_decoder *dec, VkCommandBufferUsageFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkQueryPipelineStatisticFlagBits */ + +static inline size_t +vn_sizeof_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkQueryPipelineStatisticFlagBits(struct vn_cs_encoder *enc, const VkQueryPipelineStatisticFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkQueryPipelineStatisticFlagBits(struct vn_cs_decoder *dec, VkQueryPipelineStatisticFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageAspectFlagBits */ + +static inline size_t +vn_sizeof_VkImageAspectFlagBits(const VkImageAspectFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageAspectFlagBits(struct vn_cs_encoder *enc, const VkImageAspectFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageAspectFlagBits(struct vn_cs_decoder *dec, VkImageAspectFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSparseMemoryBindFlagBits */ + +static inline size_t +vn_sizeof_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSparseMemoryBindFlagBits(struct vn_cs_encoder *enc, const VkSparseMemoryBindFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSparseMemoryBindFlagBits(struct vn_cs_decoder *dec, VkSparseMemoryBindFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSparseImageFormatFlagBits */ + +static inline size_t +vn_sizeof_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSparseImageFormatFlagBits(struct vn_cs_encoder *enc, const VkSparseImageFormatFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSparseImageFormatFlagBits(struct vn_cs_decoder *dec, VkSparseImageFormatFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSubpassDescriptionFlagBits */ + +static inline size_t +vn_sizeof_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSubpassDescriptionFlagBits(struct vn_cs_encoder *enc, const VkSubpassDescriptionFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSubpassDescriptionFlagBits(struct vn_cs_decoder *dec, VkSubpassDescriptionFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineStageFlagBits */ + +static inline size_t +vn_sizeof_VkPipelineStageFlagBits(const VkPipelineStageFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineStageFlagBits(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineStageFlagBits(struct vn_cs_decoder *dec, VkPipelineStageFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSampleCountFlagBits */ + +static inline size_t +vn_sizeof_VkSampleCountFlagBits(const VkSampleCountFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSampleCountFlagBits(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkAttachmentDescriptionFlagBits */ + +static inline size_t +vn_sizeof_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkAttachmentDescriptionFlagBits(struct vn_cs_encoder *enc, const VkAttachmentDescriptionFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkAttachmentDescriptionFlagBits(struct vn_cs_decoder *dec, VkAttachmentDescriptionFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkStencilFaceFlagBits */ + +static inline size_t +vn_sizeof_VkStencilFaceFlagBits(const VkStencilFaceFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkStencilFaceFlagBits(struct vn_cs_encoder *enc, const VkStencilFaceFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkStencilFaceFlagBits(struct vn_cs_decoder *dec, VkStencilFaceFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCullModeFlagBits */ + +static inline size_t +vn_sizeof_VkCullModeFlagBits(const VkCullModeFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCullModeFlagBits(struct vn_cs_encoder *enc, const VkCullModeFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCullModeFlagBits(struct vn_cs_decoder *dec, VkCullModeFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDescriptorPoolCreateFlagBits */ + +static inline size_t +vn_sizeof_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDescriptorPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDescriptorPoolCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorPoolCreateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDependencyFlagBits */ + +static inline size_t +vn_sizeof_VkDependencyFlagBits(const VkDependencyFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDependencyFlagBits(struct vn_cs_encoder *enc, const VkDependencyFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDependencyFlagBits(struct vn_cs_decoder *dec, VkDependencyFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSubgroupFeatureFlagBits */ + +static inline size_t +vn_sizeof_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSubgroupFeatureFlagBits(struct vn_cs_encoder *enc, const VkSubgroupFeatureFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeatureFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSemaphoreWaitFlagBits */ + +static inline size_t +vn_sizeof_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSemaphoreWaitFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreWaitFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPeerMemoryFeatureFlagBits */ + +static inline size_t +vn_sizeof_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPeerMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkPeerMemoryFeatureFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPeerMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkPeerMemoryFeatureFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkMemoryAllocateFlagBits */ + +static inline size_t +vn_sizeof_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkMemoryAllocateFlagBits(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkMemoryAllocateFlagBits(struct vn_cs_decoder *dec, VkMemoryAllocateFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkExternalMemoryHandleTypeFlagBits */ + +static inline size_t +vn_sizeof_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryHandleTypeFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryHandleTypeFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkExternalMemoryFeatureFlagBits */ + +static inline size_t +vn_sizeof_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkExternalMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryFeatureFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkExternalMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryFeatureFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkExternalSemaphoreHandleTypeFlagBits */ + +static inline size_t +vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreHandleTypeFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreHandleTypeFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkExternalSemaphoreFeatureFlagBits */ + +static inline size_t +vn_sizeof_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreFeatureFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreFeatureFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSemaphoreImportFlagBits */ + +static inline size_t +vn_sizeof_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSemaphoreImportFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreImportFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSemaphoreImportFlagBits(struct vn_cs_decoder *dec, VkSemaphoreImportFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkExternalFenceHandleTypeFlagBits */ + +static inline size_t +vn_sizeof_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceHandleTypeFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalFenceHandleTypeFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkExternalFenceFeatureFlagBits */ + +static inline size_t +vn_sizeof_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkExternalFenceFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceFeatureFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkExternalFenceFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalFenceFeatureFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkFenceImportFlagBits */ + +static inline size_t +vn_sizeof_VkFenceImportFlagBits(const VkFenceImportFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFenceImportFlagBits(struct vn_cs_encoder *enc, const VkFenceImportFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFenceImportFlagBits(struct vn_cs_decoder *dec, VkFenceImportFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDescriptorBindingFlagBits */ + +static inline size_t +vn_sizeof_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDescriptorBindingFlagBits(struct vn_cs_encoder *enc, const VkDescriptorBindingFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDescriptorBindingFlagBits(struct vn_cs_decoder *dec, VkDescriptorBindingFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkResolveModeFlagBits */ + +static inline size_t +vn_sizeof_VkResolveModeFlagBits(const VkResolveModeFlagBits *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkResolveModeFlagBits(struct vn_cs_encoder *enc, const VkResolveModeFlagBits *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkAttachmentLoadOp */ + +static inline size_t +vn_sizeof_VkAttachmentLoadOp(const VkAttachmentLoadOp *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkAttachmentLoadOp(struct vn_cs_encoder *enc, const VkAttachmentLoadOp *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkAttachmentLoadOp(struct vn_cs_decoder *dec, VkAttachmentLoadOp *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkAttachmentStoreOp */ + +static inline size_t +vn_sizeof_VkAttachmentStoreOp(const VkAttachmentStoreOp *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkAttachmentStoreOp(struct vn_cs_encoder *enc, const VkAttachmentStoreOp *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkAttachmentStoreOp(struct vn_cs_decoder *dec, VkAttachmentStoreOp *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkBlendFactor */ + +static inline size_t +vn_sizeof_VkBlendFactor(const VkBlendFactor *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkBlendFactor(struct vn_cs_encoder *enc, const VkBlendFactor *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkBlendFactor(struct vn_cs_decoder *dec, VkBlendFactor *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkBlendOp */ + +static inline size_t +vn_sizeof_VkBlendOp(const VkBlendOp *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkBlendOp(struct vn_cs_encoder *enc, const VkBlendOp *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkBlendOp(struct vn_cs_decoder *dec, VkBlendOp *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkBorderColor */ + +static inline size_t +vn_sizeof_VkBorderColor(const VkBorderColor *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkBorderColor(struct vn_cs_encoder *enc, const VkBorderColor *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkBorderColor(struct vn_cs_decoder *dec, VkBorderColor *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineCacheHeaderVersion */ + +static inline size_t +vn_sizeof_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineCacheHeaderVersion(struct vn_cs_encoder *enc, const VkPipelineCacheHeaderVersion *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineCacheHeaderVersion(struct vn_cs_decoder *dec, VkPipelineCacheHeaderVersion *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkComponentSwizzle */ + +static inline size_t +vn_sizeof_VkComponentSwizzle(const VkComponentSwizzle *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkComponentSwizzle(struct vn_cs_encoder *enc, const VkComponentSwizzle *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkComponentSwizzle(struct vn_cs_decoder *dec, VkComponentSwizzle *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandBufferLevel */ + +static inline size_t +vn_sizeof_VkCommandBufferLevel(const VkCommandBufferLevel *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandBufferLevel(struct vn_cs_encoder *enc, const VkCommandBufferLevel *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandBufferLevel(struct vn_cs_decoder *dec, VkCommandBufferLevel *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCompareOp */ + +static inline size_t +vn_sizeof_VkCompareOp(const VkCompareOp *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCompareOp(struct vn_cs_encoder *enc, const VkCompareOp *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCompareOp(struct vn_cs_decoder *dec, VkCompareOp *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDescriptorType */ + +static inline size_t +vn_sizeof_VkDescriptorType(const VkDescriptorType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDescriptorType(struct vn_cs_encoder *enc, const VkDescriptorType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDescriptorType(struct vn_cs_decoder *dec, VkDescriptorType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +static inline size_t +vn_sizeof_VkDescriptorType_array(const VkDescriptorType *val, uint32_t count) +{ + return vn_sizeof_int32_t_array((const int32_t *)val, count); +} + +static inline void +vn_encode_VkDescriptorType_array(struct vn_cs_encoder *enc, const VkDescriptorType *val, uint32_t count) +{ + vn_encode_int32_t_array(enc, (const int32_t *)val, count); +} + +static inline void +vn_decode_VkDescriptorType_array(struct vn_cs_decoder *dec, VkDescriptorType *val, uint32_t count) +{ + vn_decode_int32_t_array(dec, (int32_t *)val, count); +} + +/* enum VkDynamicState */ + +static inline size_t +vn_sizeof_VkDynamicState(const VkDynamicState *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDynamicState(struct vn_cs_encoder *enc, const VkDynamicState *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDynamicState(struct vn_cs_decoder *dec, VkDynamicState *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +static inline size_t +vn_sizeof_VkDynamicState_array(const VkDynamicState *val, uint32_t count) +{ + return vn_sizeof_int32_t_array((const int32_t *)val, count); +} + +static inline void +vn_encode_VkDynamicState_array(struct vn_cs_encoder *enc, const VkDynamicState *val, uint32_t count) +{ + vn_encode_int32_t_array(enc, (const int32_t *)val, count); +} + +static inline void +vn_decode_VkDynamicState_array(struct vn_cs_decoder *dec, VkDynamicState *val, uint32_t count) +{ + vn_decode_int32_t_array(dec, (int32_t *)val, count); +} + +/* enum VkPolygonMode */ + +static inline size_t +vn_sizeof_VkPolygonMode(const VkPolygonMode *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPolygonMode(struct vn_cs_encoder *enc, const VkPolygonMode *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPolygonMode(struct vn_cs_decoder *dec, VkPolygonMode *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkFormat */ + +static inline size_t +vn_sizeof_VkFormat(const VkFormat *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFormat(struct vn_cs_encoder *enc, const VkFormat *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFormat(struct vn_cs_decoder *dec, VkFormat *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +static inline size_t +vn_sizeof_VkFormat_array(const VkFormat *val, uint32_t count) +{ + return vn_sizeof_int32_t_array((const int32_t *)val, count); +} + +static inline void +vn_encode_VkFormat_array(struct vn_cs_encoder *enc, const VkFormat *val, uint32_t count) +{ + vn_encode_int32_t_array(enc, (const int32_t *)val, count); +} + +static inline void +vn_decode_VkFormat_array(struct vn_cs_decoder *dec, VkFormat *val, uint32_t count) +{ + vn_decode_int32_t_array(dec, (int32_t *)val, count); +} + +/* enum VkFrontFace */ + +static inline size_t +vn_sizeof_VkFrontFace(const VkFrontFace *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFrontFace(struct vn_cs_encoder *enc, const VkFrontFace *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFrontFace(struct vn_cs_decoder *dec, VkFrontFace *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageLayout */ + +static inline size_t +vn_sizeof_VkImageLayout(const VkImageLayout *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageLayout(struct vn_cs_encoder *enc, const VkImageLayout *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageLayout(struct vn_cs_decoder *dec, VkImageLayout *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageTiling */ + +static inline size_t +vn_sizeof_VkImageTiling(const VkImageTiling *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageTiling(struct vn_cs_encoder *enc, const VkImageTiling *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageTiling(struct vn_cs_decoder *dec, VkImageTiling *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageType */ + +static inline size_t +vn_sizeof_VkImageType(const VkImageType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageType(struct vn_cs_encoder *enc, const VkImageType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageType(struct vn_cs_decoder *dec, VkImageType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkImageViewType */ + +static inline size_t +vn_sizeof_VkImageViewType(const VkImageViewType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkImageViewType(struct vn_cs_encoder *enc, const VkImageViewType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkImageViewType(struct vn_cs_decoder *dec, VkImageViewType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSharingMode */ + +static inline size_t +vn_sizeof_VkSharingMode(const VkSharingMode *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSharingMode(struct vn_cs_encoder *enc, const VkSharingMode *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSharingMode(struct vn_cs_decoder *dec, VkSharingMode *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkIndexType */ + +static inline size_t +vn_sizeof_VkIndexType(const VkIndexType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkIndexType(struct vn_cs_encoder *enc, const VkIndexType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkIndexType(struct vn_cs_decoder *dec, VkIndexType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +static inline size_t +vn_sizeof_VkIndexType_array(const VkIndexType *val, uint32_t count) +{ + return vn_sizeof_int32_t_array((const int32_t *)val, count); +} + +static inline void +vn_encode_VkIndexType_array(struct vn_cs_encoder *enc, const VkIndexType *val, uint32_t count) +{ + vn_encode_int32_t_array(enc, (const int32_t *)val, count); +} + +static inline void +vn_decode_VkIndexType_array(struct vn_cs_decoder *dec, VkIndexType *val, uint32_t count) +{ + vn_decode_int32_t_array(dec, (int32_t *)val, count); +} + +/* enum VkLogicOp */ + +static inline size_t +vn_sizeof_VkLogicOp(const VkLogicOp *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkLogicOp(struct vn_cs_encoder *enc, const VkLogicOp *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkLogicOp(struct vn_cs_decoder *dec, VkLogicOp *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPhysicalDeviceType */ + +static inline size_t +vn_sizeof_VkPhysicalDeviceType(const VkPhysicalDeviceType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPhysicalDeviceType(struct vn_cs_encoder *enc, const VkPhysicalDeviceType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPhysicalDeviceType(struct vn_cs_decoder *dec, VkPhysicalDeviceType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPipelineBindPoint */ + +static inline size_t +vn_sizeof_VkPipelineBindPoint(const VkPipelineBindPoint *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPipelineBindPoint(struct vn_cs_encoder *enc, const VkPipelineBindPoint *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPipelineBindPoint(struct vn_cs_decoder *dec, VkPipelineBindPoint *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPrimitiveTopology */ + +static inline size_t +vn_sizeof_VkPrimitiveTopology(const VkPrimitiveTopology *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPrimitiveTopology(struct vn_cs_encoder *enc, const VkPrimitiveTopology *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPrimitiveTopology(struct vn_cs_decoder *dec, VkPrimitiveTopology *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkQueryType */ + +static inline size_t +vn_sizeof_VkQueryType(const VkQueryType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkQueryType(struct vn_cs_encoder *enc, const VkQueryType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkQueryType(struct vn_cs_decoder *dec, VkQueryType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSubpassContents */ + +static inline size_t +vn_sizeof_VkSubpassContents(const VkSubpassContents *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSubpassContents(struct vn_cs_encoder *enc, const VkSubpassContents *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSubpassContents(struct vn_cs_decoder *dec, VkSubpassContents *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkResult */ + +static inline size_t +vn_sizeof_VkResult(const VkResult *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkResult(struct vn_cs_encoder *enc, const VkResult *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkResult(struct vn_cs_decoder *dec, VkResult *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +static inline size_t +vn_sizeof_VkResult_array(const VkResult *val, uint32_t count) +{ + return vn_sizeof_int32_t_array((const int32_t *)val, count); +} + +static inline void +vn_encode_VkResult_array(struct vn_cs_encoder *enc, const VkResult *val, uint32_t count) +{ + vn_encode_int32_t_array(enc, (const int32_t *)val, count); +} + +static inline void +vn_decode_VkResult_array(struct vn_cs_decoder *dec, VkResult *val, uint32_t count) +{ + vn_decode_int32_t_array(dec, (int32_t *)val, count); +} + +/* enum VkStencilOp */ + +static inline size_t +vn_sizeof_VkStencilOp(const VkStencilOp *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkStencilOp(struct vn_cs_encoder *enc, const VkStencilOp *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkStencilOp(struct vn_cs_decoder *dec, VkStencilOp *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSystemAllocationScope */ + +static inline size_t +vn_sizeof_VkSystemAllocationScope(const VkSystemAllocationScope *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSystemAllocationScope(struct vn_cs_encoder *enc, const VkSystemAllocationScope *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSystemAllocationScope(struct vn_cs_decoder *dec, VkSystemAllocationScope *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkInternalAllocationType */ + +static inline size_t +vn_sizeof_VkInternalAllocationType(const VkInternalAllocationType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkInternalAllocationType(struct vn_cs_encoder *enc, const VkInternalAllocationType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkInternalAllocationType(struct vn_cs_decoder *dec, VkInternalAllocationType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSamplerAddressMode */ + +static inline size_t +vn_sizeof_VkSamplerAddressMode(const VkSamplerAddressMode *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSamplerAddressMode(struct vn_cs_encoder *enc, const VkSamplerAddressMode *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSamplerAddressMode(struct vn_cs_decoder *dec, VkSamplerAddressMode *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkFilter */ + +static inline size_t +vn_sizeof_VkFilter(const VkFilter *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkFilter(struct vn_cs_encoder *enc, const VkFilter *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkFilter(struct vn_cs_decoder *dec, VkFilter *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSamplerMipmapMode */ + +static inline size_t +vn_sizeof_VkSamplerMipmapMode(const VkSamplerMipmapMode *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSamplerMipmapMode(struct vn_cs_encoder *enc, const VkSamplerMipmapMode *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSamplerMipmapMode(struct vn_cs_decoder *dec, VkSamplerMipmapMode *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkVertexInputRate */ + +static inline size_t +vn_sizeof_VkVertexInputRate(const VkVertexInputRate *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkVertexInputRate(struct vn_cs_encoder *enc, const VkVertexInputRate *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkVertexInputRate(struct vn_cs_decoder *dec, VkVertexInputRate *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkObjectType */ + +static inline size_t +vn_sizeof_VkObjectType(const VkObjectType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkObjectType(struct vn_cs_encoder *enc, const VkObjectType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkObjectType(struct vn_cs_decoder *dec, VkObjectType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDescriptorUpdateTemplateType */ + +static inline size_t +vn_sizeof_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDescriptorUpdateTemplateType(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDescriptorUpdateTemplateType(struct vn_cs_decoder *dec, VkDescriptorUpdateTemplateType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkPointClippingBehavior */ + +static inline size_t +vn_sizeof_VkPointClippingBehavior(const VkPointClippingBehavior *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkPointClippingBehavior(struct vn_cs_encoder *enc, const VkPointClippingBehavior *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkPointClippingBehavior(struct vn_cs_decoder *dec, VkPointClippingBehavior *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSemaphoreType */ + +static inline size_t +vn_sizeof_VkSemaphoreType(const VkSemaphoreType *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSemaphoreType(struct vn_cs_encoder *enc, const VkSemaphoreType *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSemaphoreType(struct vn_cs_decoder *dec, VkSemaphoreType *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkTessellationDomainOrigin */ + +static inline size_t +vn_sizeof_VkTessellationDomainOrigin(const VkTessellationDomainOrigin *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkTessellationDomainOrigin(struct vn_cs_encoder *enc, const VkTessellationDomainOrigin *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkTessellationDomainOrigin(struct vn_cs_decoder *dec, VkTessellationDomainOrigin *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSamplerYcbcrModelConversion */ + +static inline size_t +vn_sizeof_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSamplerYcbcrModelConversion(struct vn_cs_encoder *enc, const VkSamplerYcbcrModelConversion *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSamplerYcbcrModelConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrModelConversion *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSamplerYcbcrRange */ + +static inline size_t +vn_sizeof_VkSamplerYcbcrRange(const VkSamplerYcbcrRange *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSamplerYcbcrRange(struct vn_cs_encoder *enc, const VkSamplerYcbcrRange *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSamplerYcbcrRange(struct vn_cs_decoder *dec, VkSamplerYcbcrRange *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkChromaLocation */ + +static inline size_t +vn_sizeof_VkChromaLocation(const VkChromaLocation *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkChromaLocation(struct vn_cs_encoder *enc, const VkChromaLocation *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkChromaLocation(struct vn_cs_decoder *dec, VkChromaLocation *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkSamplerReductionMode */ + +static inline size_t +vn_sizeof_VkSamplerReductionMode(const VkSamplerReductionMode *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkSamplerReductionMode(struct vn_cs_encoder *enc, const VkSamplerReductionMode *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkSamplerReductionMode(struct vn_cs_decoder *dec, VkSamplerReductionMode *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkShaderFloatControlsIndependence */ + +static inline size_t +vn_sizeof_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkShaderFloatControlsIndependence(struct vn_cs_encoder *enc, const VkShaderFloatControlsIndependence *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkShaderFloatControlsIndependence(struct vn_cs_decoder *dec, VkShaderFloatControlsIndependence *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkVendorId */ + +static inline size_t +vn_sizeof_VkVendorId(const VkVendorId *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkVendorId(struct vn_cs_encoder *enc, const VkVendorId *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkVendorId(struct vn_cs_decoder *dec, VkVendorId *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkDriverId */ + +static inline size_t +vn_sizeof_VkDriverId(const VkDriverId *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkDriverId(struct vn_cs_encoder *enc, const VkDriverId *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkDriverId(struct vn_cs_decoder *dec, VkDriverId *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandFlagBitsEXT */ + +static inline size_t +vn_sizeof_VkCommandFlagBitsEXT(const VkCommandFlagBitsEXT *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandFlagBitsEXT(struct vn_cs_encoder *enc, const VkCommandFlagBitsEXT *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandFlagBitsEXT(struct vn_cs_decoder *dec, VkCommandFlagBitsEXT *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +/* enum VkCommandTypeEXT */ + +static inline size_t +vn_sizeof_VkCommandTypeEXT(const VkCommandTypeEXT *val) +{ + assert(sizeof(*val) == sizeof(int32_t)); + return vn_sizeof_int32_t((const int32_t *)val); +} + +static inline void +vn_encode_VkCommandTypeEXT(struct vn_cs_encoder *enc, const VkCommandTypeEXT *val) +{ + vn_encode_int32_t(enc, (const int32_t *)val); +} + +static inline void +vn_decode_VkCommandTypeEXT(struct vn_cs_decoder *dec, VkCommandTypeEXT *val) +{ + vn_decode_int32_t(dec, (int32_t *)val); +} + +#endif /* VN_PROTOCOL_DRIVER_TYPES_H */