gfxstream: run codegen
Rerun codegen.
BUG=390214467
TEST=CI
Change-Id: Ifbd65ca33f787577024a4533e05d63e29860f61b
diff --git a/src/gfxstream/guest/vulkan_enc/VkEncoder.cpp b/src/gfxstream/guest/vulkan_enc/VkEncoder.cpp
index c341560..4329fac 100644
--- a/src/gfxstream/guest/vulkan_enc/VkEncoder.cpp
+++ b/src/gfxstream/guest/vulkan_enc/VkEncoder.cpp
@@ -16712,6 +16712,1300 @@
}
#endif
+#ifdef VK_VERSION_1_4
+void VkEncoder::vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_lineStippleFactor;
+ uint16_t local_lineStipplePattern;
+ local_commandBuffer = commandBuffer;
+ local_lineStippleFactor = lineStippleFactor;
+ local_lineStipplePattern = lineStipplePattern;
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(uint32_t);
+ *countPtr += sizeof(uint16_t);
+ }
+ uint32_t packetSize_vkCmdSetLineStipple = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLineStipple -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLineStipple);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdSetLineStipple = OP_vkCmdSetLineStipple;
+ memcpy(streamPtr, &opcode_vkCmdSetLineStipple, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetLineStipple, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ memcpy(*streamPtrPtr, (uint32_t*)&local_lineStippleFactor, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ memcpy(*streamPtrPtr, (uint16_t*)&local_lineStipplePattern, sizeof(uint16_t));
+ *streamPtrPtr += sizeof(uint16_t);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+VkResult VkEncoder::vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo,
+ void** ppData, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkMemoryMapInfo* local_pMemoryMapInfo;
+ local_device = device;
+ local_pMemoryMapInfo = nullptr;
+ if (pMemoryMapInfo) {
+ local_pMemoryMapInfo = (VkMemoryMapInfo*)pool->alloc(sizeof(const VkMemoryMapInfo));
+ deepcopy_VkMemoryMapInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryMapInfo,
+ (VkMemoryMapInfo*)(local_pMemoryMapInfo));
+ }
+ if (local_pMemoryMapInfo) {
+ transform_tohost_VkMemoryMapInfo(sResourceTracker,
+ (VkMemoryMapInfo*)(local_pMemoryMapInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkMemoryMapInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryMapInfo*)(local_pMemoryMapInfo), countPtr);
+ // WARNING PTR CHECK
+ *countPtr += 8;
+ if (ppData) {
+ *countPtr += sizeof(void*);
+ }
+ }
+ uint32_t packetSize_vkMapMemory2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkMapMemory2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkMapMemory2 = OP_vkMapMemory2;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkMapMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkMapMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkMemoryMapInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryMapInfo*)(local_pMemoryMapInfo), streamPtrPtr);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)ppData;
+ memcpy((*streamPtrPtr), &cgen_var_1, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*streamPtrPtr));
+ *streamPtrPtr += 8;
+ if (ppData) {
+ memcpy(*streamPtrPtr, (void**)ppData, sizeof(void*));
+ *streamPtrPtr += sizeof(void*);
+ }
+ // WARNING PTR CHECK
+ void** check_ppData;
+ check_ppData = (void**)(uintptr_t)stream->getBe64();
+ if (ppData) {
+ if (!(check_ppData)) {
+ fprintf(stderr, "fatal: ppData inconsistent between guest and host\n");
+ }
+ stream->read((void**)ppData, sizeof(void*));
+ }
+ VkResult vkMapMemory2_VkResult_return = (VkResult)0;
+ stream->read(&vkMapMemory2_VkResult_return, sizeof(VkResult));
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkMapMemory2_VkResult_return;
+}
+
+VkResult VkEncoder::vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkMemoryUnmapInfo* local_pMemoryUnmapInfo;
+ local_device = device;
+ local_pMemoryUnmapInfo = nullptr;
+ if (pMemoryUnmapInfo) {
+ local_pMemoryUnmapInfo = (VkMemoryUnmapInfo*)pool->alloc(sizeof(const VkMemoryUnmapInfo));
+ deepcopy_VkMemoryUnmapInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryUnmapInfo,
+ (VkMemoryUnmapInfo*)(local_pMemoryUnmapInfo));
+ }
+ if (local_pMemoryUnmapInfo) {
+ transform_tohost_VkMemoryUnmapInfo(sResourceTracker,
+ (VkMemoryUnmapInfo*)(local_pMemoryUnmapInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkMemoryUnmapInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryUnmapInfo*)(local_pMemoryUnmapInfo), countPtr);
+ }
+ uint32_t packetSize_vkUnmapMemory2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkUnmapMemory2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkUnmapMemory2 = OP_vkUnmapMemory2;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkUnmapMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUnmapMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkMemoryUnmapInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryUnmapInfo*)(local_pMemoryUnmapInfo), streamPtrPtr);
+ VkResult vkUnmapMemory2_VkResult_return = (VkResult)0;
+ stream->read(&vkUnmapMemory2_VkResult_return, sizeof(VkResult));
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkUnmapMemory2_VkResult_return;
+}
+
+void VkEncoder::vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ VkDeviceSize local_size;
+ VkIndexType local_indexType;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_size = size;
+ local_indexType = indexType;
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(VkDeviceSize);
+ *countPtr += sizeof(VkDeviceSize);
+ *countPtr += sizeof(VkIndexType);
+ }
+ uint32_t packetSize_vkCmdBindIndexBuffer2 = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindIndexBuffer2 -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindIndexBuffer2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdBindIndexBuffer2 = OP_vkCmdBindIndexBuffer2;
+ memcpy(streamPtr, &opcode_vkCmdBindIndexBuffer2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindIndexBuffer2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkBuffer((*&local_buffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ memcpy(*streamPtrPtr, (VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ *streamPtrPtr += sizeof(VkDeviceSize);
+ memcpy(*streamPtrPtr, (VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
+ *streamPtrPtr += sizeof(VkDeviceSize);
+ memcpy(*streamPtrPtr, (VkIndexType*)&local_indexType, sizeof(VkIndexType));
+ *streamPtrPtr += sizeof(VkIndexType);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkGetRenderingAreaGranularity(VkDevice device,
+ const VkRenderingAreaInfo* pRenderingAreaInfo,
+ VkExtent2D* pGranularity, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkRenderingAreaInfo* local_pRenderingAreaInfo;
+ local_device = device;
+ local_pRenderingAreaInfo = nullptr;
+ if (pRenderingAreaInfo) {
+ local_pRenderingAreaInfo =
+ (VkRenderingAreaInfo*)pool->alloc(sizeof(const VkRenderingAreaInfo));
+ deepcopy_VkRenderingAreaInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderingAreaInfo,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo));
+ }
+ if (local_pRenderingAreaInfo) {
+ transform_tohost_VkRenderingAreaInfo(sResourceTracker,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkRenderingAreaInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo), countPtr);
+ count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
+ countPtr);
+ }
+ uint32_t packetSize_vkGetRenderingAreaGranularity =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkGetRenderingAreaGranularity);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkGetRenderingAreaGranularity = OP_vkGetRenderingAreaGranularity;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkGetRenderingAreaGranularity, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRenderingAreaGranularity, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkRenderingAreaInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo),
+ streamPtrPtr);
+ reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
+ streamPtrPtr);
+ unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity));
+ if (pGranularity) {
+ transform_fromhost_VkExtent2D(sResourceTracker, (VkExtent2D*)(pGranularity));
+ }
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkGetDeviceImageSubresourceLayout(VkDevice device,
+ const VkDeviceImageSubresourceInfo* pInfo,
+ VkSubresourceLayout2* pLayout, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkDeviceImageSubresourceInfo* local_pInfo;
+ local_device = device;
+ local_pInfo = nullptr;
+ if (pInfo) {
+ local_pInfo =
+ (VkDeviceImageSubresourceInfo*)pool->alloc(sizeof(const VkDeviceImageSubresourceInfo));
+ deepcopy_VkDeviceImageSubresourceInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo));
+ }
+ if (local_pInfo) {
+ transform_tohost_VkDeviceImageSubresourceInfo(sResourceTracker,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkDeviceImageSubresourceInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo), countPtr);
+ count_VkSubresourceLayout2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), countPtr);
+ }
+ uint32_t packetSize_vkGetDeviceImageSubresourceLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageSubresourceLayout);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkGetDeviceImageSubresourceLayout = OP_vkGetDeviceImageSubresourceLayout;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkGetDeviceImageSubresourceLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceImageSubresourceLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkDeviceImageSubresourceInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), streamPtrPtr);
+ unmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout));
+ if (pLayout) {
+ transform_fromhost_VkSubresourceLayout2(sResourceTracker, (VkSubresourceLayout2*)(pLayout));
+ }
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkGetImageSubresourceLayout2(VkDevice device, VkImage image,
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkImage local_image;
+ VkImageSubresource2* local_pSubresource;
+ local_device = device;
+ local_image = image;
+ local_pSubresource = nullptr;
+ if (pSubresource) {
+ local_pSubresource = (VkImageSubresource2*)pool->alloc(sizeof(const VkImageSubresource2));
+ deepcopy_VkImageSubresource2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource,
+ (VkImageSubresource2*)(local_pSubresource));
+ }
+ if (local_pSubresource) {
+ transform_tohost_VkImageSubresource2(sResourceTracker,
+ (VkImageSubresource2*)(local_pSubresource));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *countPtr += 1 * 8;
+ count_VkImageSubresource2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource2*)(local_pSubresource), countPtr);
+ count_VkSubresourceLayout2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), countPtr);
+ }
+ uint32_t packetSize_vkGetImageSubresourceLayout2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSubresourceLayout2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkGetImageSubresourceLayout2 = OP_vkGetImageSubresourceLayout2;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkGetImageSubresourceLayout2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageSubresourceLayout2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *&cgen_var_1 = get_host_u64_VkImage((*&local_image));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkImageSubresource2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource2*)(local_pSubresource), streamPtrPtr);
+ reservedmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), streamPtrPtr);
+ unmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout));
+ if (pLayout) {
+ transform_fromhost_VkSubresourceLayout2(sResourceTracker, (VkSubresourceLayout2*)(pLayout));
+ }
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout, uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkPipelineBindPoint local_pipelineBindPoint;
+ VkPipelineLayout local_layout;
+ uint32_t local_set;
+ uint32_t local_descriptorWriteCount;
+ VkWriteDescriptorSet* local_pDescriptorWrites;
+ local_commandBuffer = commandBuffer;
+ local_pipelineBindPoint = pipelineBindPoint;
+ local_layout = layout;
+ local_set = set;
+ local_descriptorWriteCount = descriptorWriteCount;
+ local_pDescriptorWrites = nullptr;
+ if (pDescriptorWrites) {
+ local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(
+ ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ }
+ if (local_pDescriptorWrites) {
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ transform_tohost_VkWriteDescriptorSet(
+ sResourceTracker, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ }
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(VkPipelineBindPoint);
+ uint64_t cgen_var_1;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(uint32_t);
+ *countPtr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i),
+ countPtr);
+ }
+ }
+ uint32_t packetSize_vkCmdPushDescriptorSet = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushDescriptorSet -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushDescriptorSet);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdPushDescriptorSet = OP_vkCmdPushDescriptorSet;
+ memcpy(streamPtr, &opcode_vkCmdPushDescriptorSet, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSet, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
+ *streamPtrPtr += sizeof(VkPipelineBindPoint);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkPipelineLayout((*&local_layout));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ memcpy(*streamPtrPtr, (uint32_t*)&local_set, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i),
+ streamPtrPtr);
+ }
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdPushDescriptorSetWithTemplate(
+ VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set, const void* pData, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkDescriptorUpdateTemplate local_descriptorUpdateTemplate;
+ VkPipelineLayout local_layout;
+ uint32_t local_set;
+ void* local_pData;
+ local_commandBuffer = commandBuffer;
+ local_descriptorUpdateTemplate = descriptorUpdateTemplate;
+ local_layout = layout;
+ local_set = set;
+ // Avoiding deepcopy for pData
+ local_pData = (void*)pData;
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *countPtr += 1 * 8;
+ uint64_t cgen_var_2;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *countPtr += 8;
+ if (local_pData) {
+ *countPtr += sizeof(uint8_t);
+ }
+ }
+ uint32_t packetSize_vkCmdPushDescriptorSetWithTemplate = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushDescriptorSetWithTemplate -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushDescriptorSetWithTemplate);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdPushDescriptorSetWithTemplate = OP_vkCmdPushDescriptorSetWithTemplate;
+ memcpy(streamPtr, &opcode_vkCmdPushDescriptorSetWithTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSetWithTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDescriptorUpdateTemplate((*&local_descriptorUpdateTemplate));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ uint64_t cgen_var_1;
+ *&cgen_var_1 = get_host_u64_VkPipelineLayout((*&local_layout));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ memcpy(*streamPtrPtr, (uint32_t*)&local_set, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pData;
+ memcpy((*streamPtrPtr), &cgen_var_2, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*streamPtrPtr));
+ *streamPtrPtr += 8;
+ if (local_pData) {
+ memcpy(*streamPtrPtr, (void*)local_pData, sizeof(uint8_t));
+ *streamPtrPtr += sizeof(uint8_t);
+ }
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdSetRenderingAttachmentLocations(
+ VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkRenderingAttachmentLocationInfo* local_pLocationInfo;
+ local_commandBuffer = commandBuffer;
+ local_pLocationInfo = nullptr;
+ if (pLocationInfo) {
+ local_pLocationInfo = (VkRenderingAttachmentLocationInfo*)pool->alloc(
+ sizeof(const VkRenderingAttachmentLocationInfo));
+ deepcopy_VkRenderingAttachmentLocationInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLocationInfo,
+ (VkRenderingAttachmentLocationInfo*)(local_pLocationInfo));
+ }
+ if (local_pLocationInfo) {
+ transform_tohost_VkRenderingAttachmentLocationInfo(
+ sResourceTracker, (VkRenderingAttachmentLocationInfo*)(local_pLocationInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkRenderingAttachmentLocationInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingAttachmentLocationInfo*)(local_pLocationInfo), countPtr);
+ }
+ uint32_t packetSize_vkCmdSetRenderingAttachmentLocations = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetRenderingAttachmentLocations -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetRenderingAttachmentLocations);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdSetRenderingAttachmentLocations = OP_vkCmdSetRenderingAttachmentLocations;
+ memcpy(streamPtr, &opcode_vkCmdSetRenderingAttachmentLocations, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetRenderingAttachmentLocations, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ reservedmarshal_VkRenderingAttachmentLocationInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingAttachmentLocationInfo*)(local_pLocationInfo), streamPtrPtr);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdSetRenderingInputAttachmentIndices(
+ VkCommandBuffer commandBuffer,
+ const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo, uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkRenderingInputAttachmentIndexInfo* local_pInputAttachmentIndexInfo;
+ local_commandBuffer = commandBuffer;
+ local_pInputAttachmentIndexInfo = nullptr;
+ if (pInputAttachmentIndexInfo) {
+ local_pInputAttachmentIndexInfo = (VkRenderingInputAttachmentIndexInfo*)pool->alloc(
+ sizeof(const VkRenderingInputAttachmentIndexInfo));
+ deepcopy_VkRenderingInputAttachmentIndexInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInputAttachmentIndexInfo,
+ (VkRenderingInputAttachmentIndexInfo*)(local_pInputAttachmentIndexInfo));
+ }
+ if (local_pInputAttachmentIndexInfo) {
+ transform_tohost_VkRenderingInputAttachmentIndexInfo(
+ sResourceTracker,
+ (VkRenderingInputAttachmentIndexInfo*)(local_pInputAttachmentIndexInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkRenderingInputAttachmentIndexInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingInputAttachmentIndexInfo*)(local_pInputAttachmentIndexInfo), countPtr);
+ }
+ uint32_t packetSize_vkCmdSetRenderingInputAttachmentIndices = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetRenderingInputAttachmentIndices -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetRenderingInputAttachmentIndices);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdSetRenderingInputAttachmentIndices =
+ OP_vkCmdSetRenderingInputAttachmentIndices;
+ memcpy(streamPtr, &opcode_vkCmdSetRenderingInputAttachmentIndices, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetRenderingInputAttachmentIndices, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ reservedmarshal_VkRenderingInputAttachmentIndexInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingInputAttachmentIndexInfo*)(local_pInputAttachmentIndexInfo), streamPtrPtr);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer,
+ const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkBindDescriptorSetsInfo* local_pBindDescriptorSetsInfo;
+ local_commandBuffer = commandBuffer;
+ local_pBindDescriptorSetsInfo = nullptr;
+ if (pBindDescriptorSetsInfo) {
+ local_pBindDescriptorSetsInfo =
+ (VkBindDescriptorSetsInfo*)pool->alloc(sizeof(const VkBindDescriptorSetsInfo));
+ deepcopy_VkBindDescriptorSetsInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindDescriptorSetsInfo,
+ (VkBindDescriptorSetsInfo*)(local_pBindDescriptorSetsInfo));
+ }
+ if (local_pBindDescriptorSetsInfo) {
+ transform_tohost_VkBindDescriptorSetsInfo(
+ sResourceTracker, (VkBindDescriptorSetsInfo*)(local_pBindDescriptorSetsInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkBindDescriptorSetsInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindDescriptorSetsInfo*)(local_pBindDescriptorSetsInfo),
+ countPtr);
+ }
+ uint32_t packetSize_vkCmdBindDescriptorSets2 = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindDescriptorSets2 -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindDescriptorSets2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdBindDescriptorSets2 = OP_vkCmdBindDescriptorSets2;
+ memcpy(streamPtr, &opcode_vkCmdBindDescriptorSets2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindDescriptorSets2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ reservedmarshal_VkBindDescriptorSetsInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindDescriptorSetsInfo*)(local_pBindDescriptorSetsInfo), streamPtrPtr);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdPushConstants2(VkCommandBuffer commandBuffer,
+ const VkPushConstantsInfo* pPushConstantsInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkPushConstantsInfo* local_pPushConstantsInfo;
+ local_commandBuffer = commandBuffer;
+ local_pPushConstantsInfo = nullptr;
+ if (pPushConstantsInfo) {
+ local_pPushConstantsInfo =
+ (VkPushConstantsInfo*)pool->alloc(sizeof(const VkPushConstantsInfo));
+ deepcopy_VkPushConstantsInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPushConstantsInfo,
+ (VkPushConstantsInfo*)(local_pPushConstantsInfo));
+ }
+ if (local_pPushConstantsInfo) {
+ transform_tohost_VkPushConstantsInfo(sResourceTracker,
+ (VkPushConstantsInfo*)(local_pPushConstantsInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkPushConstantsInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPushConstantsInfo*)(local_pPushConstantsInfo), countPtr);
+ }
+ uint32_t packetSize_vkCmdPushConstants2 = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushConstants2 -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushConstants2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdPushConstants2 = OP_vkCmdPushConstants2;
+ memcpy(streamPtr, &opcode_vkCmdPushConstants2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushConstants2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ reservedmarshal_VkPushConstantsInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPushConstantsInfo*)(local_pPushConstantsInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer,
+ const VkPushDescriptorSetInfo* pPushDescriptorSetInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkPushDescriptorSetInfo* local_pPushDescriptorSetInfo;
+ local_commandBuffer = commandBuffer;
+ local_pPushDescriptorSetInfo = nullptr;
+ if (pPushDescriptorSetInfo) {
+ local_pPushDescriptorSetInfo =
+ (VkPushDescriptorSetInfo*)pool->alloc(sizeof(const VkPushDescriptorSetInfo));
+ deepcopy_VkPushDescriptorSetInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPushDescriptorSetInfo,
+ (VkPushDescriptorSetInfo*)(local_pPushDescriptorSetInfo));
+ }
+ if (local_pPushDescriptorSetInfo) {
+ transform_tohost_VkPushDescriptorSetInfo(
+ sResourceTracker, (VkPushDescriptorSetInfo*)(local_pPushDescriptorSetInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkPushDescriptorSetInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPushDescriptorSetInfo*)(local_pPushDescriptorSetInfo),
+ countPtr);
+ }
+ uint32_t packetSize_vkCmdPushDescriptorSet2 = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushDescriptorSet2 -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushDescriptorSet2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdPushDescriptorSet2 = OP_vkCmdPushDescriptorSet2;
+ memcpy(streamPtr, &opcode_vkCmdPushDescriptorSet2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSet2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ reservedmarshal_VkPushDescriptorSetInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPushDescriptorSetInfo*)(local_pPushDescriptorSetInfo), streamPtrPtr);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+void VkEncoder::vkCmdPushDescriptorSetWithTemplate2(
+ VkCommandBuffer commandBuffer,
+ const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkCommandBuffer local_commandBuffer;
+ VkPushDescriptorSetWithTemplateInfo* local_pPushDescriptorSetWithTemplateInfo;
+ local_commandBuffer = commandBuffer;
+ local_pPushDescriptorSetWithTemplateInfo = nullptr;
+ if (pPushDescriptorSetWithTemplateInfo) {
+ local_pPushDescriptorSetWithTemplateInfo =
+ (VkPushDescriptorSetWithTemplateInfo*)pool->alloc(
+ sizeof(const VkPushDescriptorSetWithTemplateInfo));
+ deepcopy_VkPushDescriptorSetWithTemplateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPushDescriptorSetWithTemplateInfo,
+ (VkPushDescriptorSetWithTemplateInfo*)(local_pPushDescriptorSetWithTemplateInfo));
+ }
+ if (local_pPushDescriptorSetWithTemplateInfo) {
+ transform_tohost_VkPushDescriptorSetWithTemplateInfo(
+ sResourceTracker,
+ (VkPushDescriptorSetWithTemplateInfo*)(local_pPushDescriptorSetWithTemplateInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkPushDescriptorSetWithTemplateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPushDescriptorSetWithTemplateInfo*)(local_pPushDescriptorSetWithTemplateInfo),
+ countPtr);
+ }
+ uint32_t packetSize_vkCmdPushDescriptorSetWithTemplate2 = 4 + 4 + count;
+ if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushDescriptorSetWithTemplate2 -= 8;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushDescriptorSetWithTemplate2);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCmdPushDescriptorSetWithTemplate2 = OP_vkCmdPushDescriptorSetWithTemplate2;
+ memcpy(streamPtr, &opcode_vkCmdPushDescriptorSetWithTemplate2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSetWithTemplate2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ }
+ reservedmarshal_VkPushDescriptorSetWithTemplateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPushDescriptorSetWithTemplateInfo*)(local_pPushDescriptorSetWithTemplateInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+}
+
+VkResult VkEncoder::vkCopyMemoryToImage(VkDevice device,
+ const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkCopyMemoryToImageInfo* local_pCopyMemoryToImageInfo;
+ local_device = device;
+ local_pCopyMemoryToImageInfo = nullptr;
+ if (pCopyMemoryToImageInfo) {
+ local_pCopyMemoryToImageInfo =
+ (VkCopyMemoryToImageInfo*)pool->alloc(sizeof(const VkCopyMemoryToImageInfo));
+ deepcopy_VkCopyMemoryToImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyMemoryToImageInfo,
+ (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo));
+ }
+ if (local_pCopyMemoryToImageInfo) {
+ transform_tohost_VkCopyMemoryToImageInfo(
+ sResourceTracker, (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkCopyMemoryToImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo),
+ countPtr);
+ }
+ uint32_t packetSize_vkCopyMemoryToImage =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCopyMemoryToImage);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCopyMemoryToImage = OP_vkCopyMemoryToImage;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkCopyMemoryToImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCopyMemoryToImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkCopyMemoryToImageInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo), streamPtrPtr);
+ VkResult vkCopyMemoryToImage_VkResult_return = (VkResult)0;
+ stream->read(&vkCopyMemoryToImage_VkResult_return, sizeof(VkResult));
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkCopyMemoryToImage_VkResult_return;
+}
+
+VkResult VkEncoder::vkCopyImageToMemory(VkDevice device,
+ const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkCopyImageToMemoryInfo* local_pCopyImageToMemoryInfo;
+ local_device = device;
+ local_pCopyImageToMemoryInfo = nullptr;
+ if (pCopyImageToMemoryInfo) {
+ local_pCopyImageToMemoryInfo =
+ (VkCopyImageToMemoryInfo*)pool->alloc(sizeof(const VkCopyImageToMemoryInfo));
+ deepcopy_VkCopyImageToMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToMemoryInfo,
+ (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo));
+ }
+ if (local_pCopyImageToMemoryInfo) {
+ transform_tohost_VkCopyImageToMemoryInfo(
+ sResourceTracker, (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkCopyImageToMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo),
+ countPtr);
+ }
+ uint32_t packetSize_vkCopyImageToMemory =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCopyImageToMemory);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCopyImageToMemory = OP_vkCopyImageToMemory;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkCopyImageToMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCopyImageToMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkCopyImageToMemoryInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo), streamPtrPtr);
+ VkResult vkCopyImageToMemory_VkResult_return = (VkResult)0;
+ stream->read(&vkCopyImageToMemory_VkResult_return, sizeof(VkResult));
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkCopyImageToMemory_VkResult_return;
+}
+
+VkResult VkEncoder::vkCopyImageToImage(VkDevice device,
+ const VkCopyImageToImageInfo* pCopyImageToImageInfo,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ VkCopyImageToImageInfo* local_pCopyImageToImageInfo;
+ local_device = device;
+ local_pCopyImageToImageInfo = nullptr;
+ if (pCopyImageToImageInfo) {
+ local_pCopyImageToImageInfo =
+ (VkCopyImageToImageInfo*)pool->alloc(sizeof(const VkCopyImageToImageInfo));
+ deepcopy_VkCopyImageToImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToImageInfo,
+ (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo));
+ }
+ if (local_pCopyImageToImageInfo) {
+ transform_tohost_VkCopyImageToImageInfo(
+ sResourceTracker, (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo));
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ count_VkCopyImageToImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo),
+ countPtr);
+ }
+ uint32_t packetSize_vkCopyImageToImage =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkCopyImageToImage);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkCopyImageToImage = OP_vkCopyImageToImage;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkCopyImageToImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCopyImageToImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ reservedmarshal_VkCopyImageToImageInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo),
+ streamPtrPtr);
+ VkResult vkCopyImageToImage_VkResult_return = (VkResult)0;
+ stream->read(&vkCopyImageToImage_VkResult_return, sizeof(VkResult));
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkCopyImageToImage_VkResult_return;
+}
+
+VkResult VkEncoder::vkTransitionImageLayout(VkDevice device, uint32_t transitionCount,
+ const VkHostImageLayoutTransitionInfo* pTransitions,
+ uint32_t doLock) {
+ (void)doLock;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
+ auto stream = mImpl->stream();
+ auto pool = mImpl->pool();
+ VkDevice local_device;
+ uint32_t local_transitionCount;
+ VkHostImageLayoutTransitionInfo* local_pTransitions;
+ local_device = device;
+ local_transitionCount = transitionCount;
+ local_pTransitions = nullptr;
+ if (pTransitions) {
+ local_pTransitions = (VkHostImageLayoutTransitionInfo*)pool->alloc(
+ ((transitionCount)) * sizeof(const VkHostImageLayoutTransitionInfo));
+ for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
+ deepcopy_VkHostImageLayoutTransitionInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTransitions + i,
+ (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i));
+ }
+ }
+ if (local_pTransitions) {
+ for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
+ transform_tohost_VkHostImageLayoutTransitionInfo(
+ sResourceTracker, (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i));
+ }
+ }
+ size_t count = 0;
+ size_t* countPtr = &count;
+ {
+ uint64_t cgen_var_0;
+ *countPtr += 1 * 8;
+ *countPtr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
+ count_VkHostImageLayoutTransitionInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i), countPtr);
+ }
+ }
+ uint32_t packetSize_vkTransitionImageLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint8_t* streamPtr = stream->reserve(packetSize_vkTransitionImageLayout);
+ uint8_t* packetBeginPtr = streamPtr;
+ uint8_t** streamPtrPtr = &streamPtr;
+ uint32_t opcode_vkTransitionImageLayout = OP_vkTransitionImageLayout;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ memcpy(streamPtr, &opcode_vkTransitionImageLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkTransitionImageLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
+ memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *streamPtrPtr += 1 * 8;
+ memcpy(*streamPtrPtr, (uint32_t*)&local_transitionCount, sizeof(uint32_t));
+ *streamPtrPtr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
+ reservedmarshal_VkHostImageLayoutTransitionInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i), streamPtrPtr);
+ }
+ VkResult vkTransitionImageLayout_VkResult_return = (VkResult)0;
+ stream->read(&vkTransitionImageLayout_VkResult_return, sizeof(VkResult));
+ ++encodeCount;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
+ pool->freeAll();
+ stream->clearPool();
+ }
+ if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
+ return vkTransitionImageLayout_VkResult_return;
+}
+
+#endif
#ifdef VK_KHR_dynamic_rendering
void VkEncoder::vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
const VkRenderingInfo* pRenderingInfo, uint32_t doLock) {
@@ -20282,183 +21576,6 @@
return vkQueueSubmit2KHR_VkResult_return;
}
-void VkEncoder::vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, uint32_t marker,
- uint32_t doLock) {
- (void)doLock;
- bool queueSubmitWithCommandsEnabled =
- sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
- if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- auto stream = mImpl->stream();
- auto pool = mImpl->pool();
- VkCommandBuffer local_commandBuffer;
- VkPipelineStageFlags2 local_stage;
- VkBuffer local_dstBuffer;
- VkDeviceSize local_dstOffset;
- uint32_t local_marker;
- local_commandBuffer = commandBuffer;
- local_stage = stage;
- local_dstBuffer = dstBuffer;
- local_dstOffset = dstOffset;
- local_marker = marker;
- size_t count = 0;
- size_t* countPtr = &count;
- {
- uint64_t cgen_var_0;
- *countPtr += 1 * 8;
- *countPtr += sizeof(VkPipelineStageFlags2);
- uint64_t cgen_var_1;
- *countPtr += 1 * 8;
- *countPtr += sizeof(VkDeviceSize);
- *countPtr += sizeof(uint32_t);
- }
- uint32_t packetSize_vkCmdWriteBufferMarker2AMD = 4 + 4 + count;
- if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteBufferMarker2AMD -= 8;
- uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteBufferMarker2AMD);
- uint8_t* packetBeginPtr = streamPtr;
- uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdWriteBufferMarker2AMD = OP_vkCmdWriteBufferMarker2AMD;
- memcpy(streamPtr, &opcode_vkCmdWriteBufferMarker2AMD, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteBufferMarker2AMD, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled) {
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
- *streamPtrPtr += 1 * 8;
- }
- memcpy(*streamPtrPtr, (VkPipelineStageFlags2*)&local_stage, sizeof(VkPipelineStageFlags2));
- *streamPtrPtr += sizeof(VkPipelineStageFlags2);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkBuffer((*&local_dstBuffer));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
- *streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
- *streamPtrPtr += sizeof(VkDeviceSize);
- memcpy(*streamPtrPtr, (uint32_t*)&local_marker, sizeof(uint32_t));
- *streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
- pool->freeAll();
- stream->clearPool();
- }
- if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
-}
-
-void VkEncoder::vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData, uint32_t doLock) {
- (void)doLock;
- bool queueSubmitWithCommandsEnabled =
- sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
- if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- auto stream = mImpl->stream();
- auto pool = mImpl->pool();
- VkQueue local_queue;
- local_queue = queue;
- size_t count = 0;
- size_t* countPtr = &count;
- {
- uint64_t cgen_var_0;
- *countPtr += 1 * 8;
- // WARNING PTR CHECK
- *countPtr += 8;
- if (pCheckpointDataCount) {
- *countPtr += sizeof(uint32_t);
- }
- // WARNING PTR CHECK
- *countPtr += 8;
- if (pCheckpointData) {
- if (pCheckpointDataCount) {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
- count_VkCheckpointData2NV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCheckpointData2NV*)(pCheckpointData + i),
- countPtr);
- }
- }
- }
- }
- uint32_t packetSize_vkGetQueueCheckpointData2NV =
- 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetQueueCheckpointData2NV);
- uint8_t* packetBeginPtr = streamPtr;
- uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetQueueCheckpointData2NV = OP_vkGetQueueCheckpointData2NV;
- uint32_t seqno;
- if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetQueueCheckpointData2NV, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetQueueCheckpointData2NV, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) {
- memcpy(streamPtr, &seqno, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- }
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
- *streamPtrPtr += 1 * 8;
- // WARNING PTR CHECK
- uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pCheckpointDataCount;
- memcpy((*streamPtrPtr), &cgen_var_1, 8);
- gfxstream::aemu::Stream::toBe64((uint8_t*)(*streamPtrPtr));
- *streamPtrPtr += 8;
- if (pCheckpointDataCount) {
- memcpy(*streamPtrPtr, (uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
- *streamPtrPtr += sizeof(uint32_t);
- }
- // WARNING PTR CHECK
- uint64_t cgen_var_2 = (uint64_t)(uintptr_t)pCheckpointData;
- memcpy((*streamPtrPtr), &cgen_var_2, 8);
- gfxstream::aemu::Stream::toBe64((uint8_t*)(*streamPtrPtr));
- *streamPtrPtr += 8;
- if (pCheckpointData) {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
- reservedmarshal_VkCheckpointData2NV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCheckpointData2NV*)(pCheckpointData + i),
- streamPtrPtr);
- }
- }
- // WARNING PTR CHECK
- uint32_t* check_pCheckpointDataCount;
- check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pCheckpointDataCount) {
- if (!(check_pCheckpointDataCount)) {
- fprintf(stderr, "fatal: pCheckpointDataCount inconsistent between guest and host\n");
- }
- stream->read((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
- }
- // WARNING PTR CHECK
- VkCheckpointData2NV* check_pCheckpointData;
- check_pCheckpointData = (VkCheckpointData2NV*)(uintptr_t)stream->getBe64();
- if (pCheckpointData) {
- if (!(check_pCheckpointData)) {
- fprintf(stderr, "fatal: pCheckpointData inconsistent between guest and host\n");
- }
- if (pCheckpointDataCount) {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
- unmarshal_VkCheckpointData2NV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCheckpointData2NV*)(pCheckpointData + i));
- }
- }
- }
- if (pCheckpointDataCount) {
- if (pCheckpointData) {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
- transform_fromhost_VkCheckpointData2NV(sResourceTracker,
- (VkCheckpointData2NV*)(pCheckpointData + i));
- }
- }
- }
- ++encodeCount;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
- pool->freeAll();
- stream->clearPool();
- }
- if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
-}
-
#endif
#ifdef VK_KHR_copy_commands2
void VkEncoder::vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
@@ -21163,7 +22280,7 @@
}
void VkEncoder::vkGetRenderingAreaGranularityKHR(VkDevice device,
- const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+ const VkRenderingAreaInfo* pRenderingAreaInfo,
VkExtent2D* pGranularity, uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -21172,26 +22289,26 @@
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
- VkRenderingAreaInfoKHR* local_pRenderingAreaInfo;
+ VkRenderingAreaInfo* local_pRenderingAreaInfo;
local_device = device;
local_pRenderingAreaInfo = nullptr;
if (pRenderingAreaInfo) {
local_pRenderingAreaInfo =
- (VkRenderingAreaInfoKHR*)pool->alloc(sizeof(const VkRenderingAreaInfoKHR));
- deepcopy_VkRenderingAreaInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderingAreaInfo,
- (VkRenderingAreaInfoKHR*)(local_pRenderingAreaInfo));
+ (VkRenderingAreaInfo*)pool->alloc(sizeof(const VkRenderingAreaInfo));
+ deepcopy_VkRenderingAreaInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderingAreaInfo,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo));
}
if (local_pRenderingAreaInfo) {
- transform_tohost_VkRenderingAreaInfoKHR(
- sResourceTracker, (VkRenderingAreaInfoKHR*)(local_pRenderingAreaInfo));
+ transform_tohost_VkRenderingAreaInfo(sResourceTracker,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderingAreaInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkRenderingAreaInfoKHR*)(local_pRenderingAreaInfo), countPtr);
+ count_VkRenderingAreaInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo), countPtr);
count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
countPtr);
}
@@ -21215,9 +22332,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderingAreaInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkRenderingAreaInfoKHR*)(local_pRenderingAreaInfo),
- streamPtrPtr);
+ reservedmarshal_VkRenderingAreaInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingAreaInfo*)(local_pRenderingAreaInfo),
+ streamPtrPtr);
reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
streamPtrPtr);
unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity));
@@ -21233,8 +22350,8 @@
}
void VkEncoder::vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
- const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout,
+ const VkDeviceImageSubresourceInfo* pInfo,
+ VkSubresourceLayout2* pLayout,
uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -21243,29 +22360,28 @@
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
- VkDeviceImageSubresourceInfoKHR* local_pInfo;
+ VkDeviceImageSubresourceInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
if (pInfo) {
- local_pInfo = (VkDeviceImageSubresourceInfoKHR*)pool->alloc(
- sizeof(const VkDeviceImageSubresourceInfoKHR));
- deepcopy_VkDeviceImageSubresourceInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
- (VkDeviceImageSubresourceInfoKHR*)(local_pInfo));
+ local_pInfo =
+ (VkDeviceImageSubresourceInfo*)pool->alloc(sizeof(const VkDeviceImageSubresourceInfo));
+ deepcopy_VkDeviceImageSubresourceInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo));
}
if (local_pInfo) {
- transform_tohost_VkDeviceImageSubresourceInfoKHR(
- sResourceTracker, (VkDeviceImageSubresourceInfoKHR*)(local_pInfo));
+ transform_tohost_VkDeviceImageSubresourceInfo(sResourceTracker,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceImageSubresourceInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkDeviceImageSubresourceInfoKHR*)(local_pInfo),
- countPtr);
- count_VkSubresourceLayout2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout), countPtr);
+ count_VkDeviceImageSubresourceInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo), countPtr);
+ count_VkSubresourceLayout2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), countPtr);
}
uint32_t packetSize_vkGetDeviceImageSubresourceLayoutKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -21287,16 +22403,15 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceImageSubresourceInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkDeviceImageSubresourceInfoKHR*)(local_pInfo),
- streamPtrPtr);
- reservedmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout), streamPtrPtr);
- unmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout));
+ reservedmarshal_VkDeviceImageSubresourceInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceImageSubresourceInfo*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), streamPtrPtr);
+ unmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout));
if (pLayout) {
- transform_fromhost_VkSubresourceLayout2KHR(sResourceTracker,
- (VkSubresourceLayout2KHR*)(pLayout));
+ transform_fromhost_VkSubresourceLayout2(sResourceTracker, (VkSubresourceLayout2*)(pLayout));
}
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -21307,8 +22422,8 @@
}
void VkEncoder::vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout, uint32_t doLock) {
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout, uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -21317,19 +22432,18 @@
auto pool = mImpl->pool();
VkDevice local_device;
VkImage local_image;
- VkImageSubresource2KHR* local_pSubresource;
+ VkImageSubresource2* local_pSubresource;
local_device = device;
local_image = image;
local_pSubresource = nullptr;
if (pSubresource) {
- local_pSubresource =
- (VkImageSubresource2KHR*)pool->alloc(sizeof(const VkImageSubresource2KHR));
- deepcopy_VkImageSubresource2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource,
- (VkImageSubresource2KHR*)(local_pSubresource));
+ local_pSubresource = (VkImageSubresource2*)pool->alloc(sizeof(const VkImageSubresource2));
+ deepcopy_VkImageSubresource2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource,
+ (VkImageSubresource2*)(local_pSubresource));
}
if (local_pSubresource) {
- transform_tohost_VkImageSubresource2KHR(sResourceTracker,
- (VkImageSubresource2KHR*)(local_pSubresource));
+ transform_tohost_VkImageSubresource2(sResourceTracker,
+ (VkImageSubresource2*)(local_pSubresource));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -21338,10 +22452,10 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageSubresource2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkImageSubresource2KHR*)(local_pSubresource), countPtr);
- count_VkSubresourceLayout2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout), countPtr);
+ count_VkImageSubresource2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource2*)(local_pSubresource), countPtr);
+ count_VkSubresourceLayout2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), countPtr);
}
uint32_t packetSize_vkGetImageSubresourceLayout2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -21367,16 +22481,14 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSubresource2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkImageSubresource2KHR*)(local_pSubresource),
- streamPtrPtr);
- reservedmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout), streamPtrPtr);
- unmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout));
+ reservedmarshal_VkImageSubresource2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource2*)(local_pSubresource), streamPtrPtr);
+ reservedmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), streamPtrPtr);
+ unmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout));
if (pLayout) {
- transform_fromhost_VkSubresourceLayout2KHR(sResourceTracker,
- (VkSubresourceLayout2KHR*)(pLayout));
+ transform_fromhost_VkSubresourceLayout2(sResourceTracker, (VkSubresourceLayout2*)(pLayout));
}
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -23151,7 +24263,7 @@
#endif
#ifdef VK_EXT_host_image_copy
VkResult VkEncoder::vkCopyMemoryToImageEXT(VkDevice device,
- const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo,
+ const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo,
uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23160,28 +24272,27 @@
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
- VkCopyMemoryToImageInfoEXT* local_pCopyMemoryToImageInfo;
+ VkCopyMemoryToImageInfo* local_pCopyMemoryToImageInfo;
local_device = device;
local_pCopyMemoryToImageInfo = nullptr;
if (pCopyMemoryToImageInfo) {
local_pCopyMemoryToImageInfo =
- (VkCopyMemoryToImageInfoEXT*)pool->alloc(sizeof(const VkCopyMemoryToImageInfoEXT));
- deepcopy_VkCopyMemoryToImageInfoEXT(
- pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyMemoryToImageInfo,
- (VkCopyMemoryToImageInfoEXT*)(local_pCopyMemoryToImageInfo));
+ (VkCopyMemoryToImageInfo*)pool->alloc(sizeof(const VkCopyMemoryToImageInfo));
+ deepcopy_VkCopyMemoryToImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyMemoryToImageInfo,
+ (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo));
}
if (local_pCopyMemoryToImageInfo) {
- transform_tohost_VkCopyMemoryToImageInfoEXT(
- sResourceTracker, (VkCopyMemoryToImageInfoEXT*)(local_pCopyMemoryToImageInfo));
+ transform_tohost_VkCopyMemoryToImageInfo(
+ sResourceTracker, (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyMemoryToImageInfoEXT(
- sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyMemoryToImageInfoEXT*)(local_pCopyMemoryToImageInfo), countPtr);
+ count_VkCopyMemoryToImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo),
+ countPtr);
}
uint32_t packetSize_vkCopyMemoryToImageEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -23203,9 +24314,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCopyMemoryToImageInfoEXT(
+ reservedmarshal_VkCopyMemoryToImageInfo(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyMemoryToImageInfoEXT*)(local_pCopyMemoryToImageInfo), streamPtrPtr);
+ (VkCopyMemoryToImageInfo*)(local_pCopyMemoryToImageInfo), streamPtrPtr);
VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
stream->read(&vkCopyMemoryToImageEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -23218,7 +24329,7 @@
}
VkResult VkEncoder::vkCopyImageToMemoryEXT(VkDevice device,
- const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo,
+ const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo,
uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23227,28 +24338,27 @@
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
- VkCopyImageToMemoryInfoEXT* local_pCopyImageToMemoryInfo;
+ VkCopyImageToMemoryInfo* local_pCopyImageToMemoryInfo;
local_device = device;
local_pCopyImageToMemoryInfo = nullptr;
if (pCopyImageToMemoryInfo) {
local_pCopyImageToMemoryInfo =
- (VkCopyImageToMemoryInfoEXT*)pool->alloc(sizeof(const VkCopyImageToMemoryInfoEXT));
- deepcopy_VkCopyImageToMemoryInfoEXT(
- pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToMemoryInfo,
- (VkCopyImageToMemoryInfoEXT*)(local_pCopyImageToMemoryInfo));
+ (VkCopyImageToMemoryInfo*)pool->alloc(sizeof(const VkCopyImageToMemoryInfo));
+ deepcopy_VkCopyImageToMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToMemoryInfo,
+ (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo));
}
if (local_pCopyImageToMemoryInfo) {
- transform_tohost_VkCopyImageToMemoryInfoEXT(
- sResourceTracker, (VkCopyImageToMemoryInfoEXT*)(local_pCopyImageToMemoryInfo));
+ transform_tohost_VkCopyImageToMemoryInfo(
+ sResourceTracker, (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyImageToMemoryInfoEXT(
- sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyImageToMemoryInfoEXT*)(local_pCopyImageToMemoryInfo), countPtr);
+ count_VkCopyImageToMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo),
+ countPtr);
}
uint32_t packetSize_vkCopyImageToMemoryEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -23270,9 +24380,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCopyImageToMemoryInfoEXT(
+ reservedmarshal_VkCopyImageToMemoryInfo(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyImageToMemoryInfoEXT*)(local_pCopyImageToMemoryInfo), streamPtrPtr);
+ (VkCopyImageToMemoryInfo*)(local_pCopyImageToMemoryInfo), streamPtrPtr);
VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
stream->read(&vkCopyImageToMemoryEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -23285,7 +24395,7 @@
}
VkResult VkEncoder::vkCopyImageToImageEXT(VkDevice device,
- const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo,
+ const VkCopyImageToImageInfo* pCopyImageToImageInfo,
uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23294,28 +24404,27 @@
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
- VkCopyImageToImageInfoEXT* local_pCopyImageToImageInfo;
+ VkCopyImageToImageInfo* local_pCopyImageToImageInfo;
local_device = device;
local_pCopyImageToImageInfo = nullptr;
if (pCopyImageToImageInfo) {
local_pCopyImageToImageInfo =
- (VkCopyImageToImageInfoEXT*)pool->alloc(sizeof(const VkCopyImageToImageInfoEXT));
- deepcopy_VkCopyImageToImageInfoEXT(
- pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToImageInfo,
- (VkCopyImageToImageInfoEXT*)(local_pCopyImageToImageInfo));
+ (VkCopyImageToImageInfo*)pool->alloc(sizeof(const VkCopyImageToImageInfo));
+ deepcopy_VkCopyImageToImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToImageInfo,
+ (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo));
}
if (local_pCopyImageToImageInfo) {
- transform_tohost_VkCopyImageToImageInfoEXT(
- sResourceTracker, (VkCopyImageToImageInfoEXT*)(local_pCopyImageToImageInfo));
+ transform_tohost_VkCopyImageToImageInfo(
+ sResourceTracker, (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyImageToImageInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyImageToImageInfoEXT*)(local_pCopyImageToImageInfo),
- countPtr);
+ count_VkCopyImageToImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo),
+ countPtr);
}
uint32_t packetSize_vkCopyImageToImageEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -23337,9 +24446,9 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCopyImageToImageInfoEXT(
- stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyImageToImageInfoEXT*)(local_pCopyImageToImageInfo), streamPtrPtr);
+ reservedmarshal_VkCopyImageToImageInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToImageInfo*)(local_pCopyImageToImageInfo),
+ streamPtrPtr);
VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
stream->read(&vkCopyImageToImageEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -23351,9 +24460,9 @@
return vkCopyImageToImageEXT_VkResult_return;
}
-VkResult VkEncoder::vkTransitionImageLayoutEXT(
- VkDevice device, uint32_t transitionCount,
- const VkHostImageLayoutTransitionInfoEXT* pTransitions, uint32_t doLock) {
+VkResult VkEncoder::vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount,
+ const VkHostImageLayoutTransitionInfo* pTransitions,
+ uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -23362,23 +24471,23 @@
auto pool = mImpl->pool();
VkDevice local_device;
uint32_t local_transitionCount;
- VkHostImageLayoutTransitionInfoEXT* local_pTransitions;
+ VkHostImageLayoutTransitionInfo* local_pTransitions;
local_device = device;
local_transitionCount = transitionCount;
local_pTransitions = nullptr;
if (pTransitions) {
- local_pTransitions = (VkHostImageLayoutTransitionInfoEXT*)pool->alloc(
- ((transitionCount)) * sizeof(const VkHostImageLayoutTransitionInfoEXT));
+ local_pTransitions = (VkHostImageLayoutTransitionInfo*)pool->alloc(
+ ((transitionCount)) * sizeof(const VkHostImageLayoutTransitionInfo));
for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
- deepcopy_VkHostImageLayoutTransitionInfoEXT(
+ deepcopy_VkHostImageLayoutTransitionInfo(
pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTransitions + i,
- (VkHostImageLayoutTransitionInfoEXT*)(local_pTransitions + i));
+ (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i));
}
}
if (local_pTransitions) {
for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
- transform_tohost_VkHostImageLayoutTransitionInfoEXT(
- sResourceTracker, (VkHostImageLayoutTransitionInfoEXT*)(local_pTransitions + i));
+ transform_tohost_VkHostImageLayoutTransitionInfo(
+ sResourceTracker, (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i));
}
}
size_t count = 0;
@@ -23388,9 +24497,9 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
- count_VkHostImageLayoutTransitionInfoEXT(
+ count_VkHostImageLayoutTransitionInfo(
sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkHostImageLayoutTransitionInfoEXT*)(local_pTransitions + i), countPtr);
+ (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i), countPtr);
}
}
uint32_t packetSize_vkTransitionImageLayoutEXT =
@@ -23416,9 +24525,9 @@
memcpy(*streamPtrPtr, (uint32_t*)&local_transitionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
- reservedmarshal_VkHostImageLayoutTransitionInfoEXT(
+ reservedmarshal_VkHostImageLayoutTransitionInfo(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkHostImageLayoutTransitionInfoEXT*)(local_pTransitions + i), streamPtrPtr);
+ (VkHostImageLayoutTransitionInfo*)(local_pTransitions + i), streamPtrPtr);
}
VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
stream->read(&vkTransitionImageLayoutEXT_VkResult_return, sizeof(VkResult));
@@ -23432,8 +24541,8 @@
}
void VkEncoder::vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout, uint32_t doLock) {
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout, uint32_t doLock) {
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -23442,19 +24551,18 @@
auto pool = mImpl->pool();
VkDevice local_device;
VkImage local_image;
- VkImageSubresource2KHR* local_pSubresource;
+ VkImageSubresource2* local_pSubresource;
local_device = device;
local_image = image;
local_pSubresource = nullptr;
if (pSubresource) {
- local_pSubresource =
- (VkImageSubresource2KHR*)pool->alloc(sizeof(const VkImageSubresource2KHR));
- deepcopy_VkImageSubresource2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource,
- (VkImageSubresource2KHR*)(local_pSubresource));
+ local_pSubresource = (VkImageSubresource2*)pool->alloc(sizeof(const VkImageSubresource2));
+ deepcopy_VkImageSubresource2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource,
+ (VkImageSubresource2*)(local_pSubresource));
}
if (local_pSubresource) {
- transform_tohost_VkImageSubresource2KHR(sResourceTracker,
- (VkImageSubresource2KHR*)(local_pSubresource));
+ transform_tohost_VkImageSubresource2(sResourceTracker,
+ (VkImageSubresource2*)(local_pSubresource));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -23463,10 +24571,10 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageSubresource2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkImageSubresource2KHR*)(local_pSubresource), countPtr);
- count_VkSubresourceLayout2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout), countPtr);
+ count_VkImageSubresource2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource2*)(local_pSubresource), countPtr);
+ count_VkSubresourceLayout2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), countPtr);
}
uint32_t packetSize_vkGetImageSubresourceLayout2EXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
@@ -23492,16 +24600,14 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSubresource2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkImageSubresource2KHR*)(local_pSubresource),
- streamPtrPtr);
- reservedmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout), streamPtrPtr);
- unmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkSubresourceLayout2KHR*)(pLayout));
+ reservedmarshal_VkImageSubresource2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource2*)(local_pSubresource), streamPtrPtr);
+ reservedmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout), streamPtrPtr);
+ unmarshal_VkSubresourceLayout2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout2*)(pLayout));
if (pLayout) {
- transform_fromhost_VkSubresourceLayout2KHR(sResourceTracker,
- (VkSubresourceLayout2KHR*)(pLayout));
+ transform_fromhost_VkSubresourceLayout2(sResourceTracker, (VkSubresourceLayout2*)(pLayout));
}
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
diff --git a/src/gfxstream/guest/vulkan_enc/VkEncoder.h b/src/gfxstream/guest/vulkan_enc/VkEncoder.h
index fe1c4cf..a69b165 100644
--- a/src/gfxstream/guest/vulkan_enc/VkEncoder.h
+++ b/src/gfxstream/guest/vulkan_enc/VkEncoder.h
@@ -614,6 +614,63 @@
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock);
#endif
+#ifdef VK_VERSION_1_4
+ void vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern, uint32_t doLock);
+ VkResult vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData,
+ uint32_t doLock);
+ VkResult vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo,
+ uint32_t doLock);
+ void vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+ VkDeviceSize size, VkIndexType indexType, uint32_t doLock);
+ void vkGetRenderingAreaGranularity(VkDevice device,
+ const VkRenderingAreaInfo* pRenderingAreaInfo,
+ VkExtent2D* pGranularity, uint32_t doLock);
+ void vkGetDeviceImageSubresourceLayout(VkDevice device,
+ const VkDeviceImageSubresourceInfo* pInfo,
+ VkSubresourceLayout2* pLayout, uint32_t doLock);
+ void vkGetImageSubresourceLayout2(VkDevice device, VkImage image,
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout, uint32_t doLock);
+ void vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+ uint32_t set, uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites, uint32_t doLock);
+ void vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set,
+ const void* pData, uint32_t doLock);
+ void vkCmdSetRenderingAttachmentLocations(
+ VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo,
+ uint32_t doLock);
+ void vkCmdSetRenderingInputAttachmentIndices(
+ VkCommandBuffer commandBuffer,
+ const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo, uint32_t doLock);
+ void vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer,
+ const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo,
+ uint32_t doLock);
+ void vkCmdPushConstants2(VkCommandBuffer commandBuffer,
+ const VkPushConstantsInfo* pPushConstantsInfo, uint32_t doLock);
+ void vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer,
+ const VkPushDescriptorSetInfo* pPushDescriptorSetInfo,
+ uint32_t doLock);
+ void vkCmdPushDescriptorSetWithTemplate2(
+ VkCommandBuffer commandBuffer,
+ const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo,
+ uint32_t doLock);
+ VkResult vkCopyMemoryToImage(VkDevice device,
+ const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo,
+ uint32_t doLock);
+ VkResult vkCopyImageToMemory(VkDevice device,
+ const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo,
+ uint32_t doLock);
+ VkResult vkCopyImageToImage(VkDevice device,
+ const VkCopyImageToImageInfo* pCopyImageToImageInfo,
+ uint32_t doLock);
+ VkResult vkTransitionImageLayout(VkDevice device, uint32_t transitionCount,
+ const VkHostImageLayoutTransitionInfo* pTransitions,
+ uint32_t doLock);
+#endif
#ifdef VK_KHR_dynamic_rendering
void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
const VkRenderingInfo* pRenderingInfo, uint32_t doLock);
@@ -776,11 +833,6 @@
VkQueryPool queryPool, uint32_t query, uint32_t doLock);
VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
VkFence fence, uint32_t doLock);
- void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
- VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker,
- uint32_t doLock);
- void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData, uint32_t doLock);
#endif
#ifdef VK_KHR_copy_commands2
void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
@@ -817,14 +869,14 @@
VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType,
uint32_t doLock);
void vkGetRenderingAreaGranularityKHR(VkDevice device,
- const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+ const VkRenderingAreaInfo* pRenderingAreaInfo,
VkExtent2D* pGranularity, uint32_t doLock);
void vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
- const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout, uint32_t doLock);
+ const VkDeviceImageSubresourceInfo* pInfo,
+ VkSubresourceLayout2* pLayout, uint32_t doLock);
void vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout, uint32_t doLock);
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout, uint32_t doLock);
#endif
#ifdef VK_KHR_line_rasterization
void vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
@@ -912,20 +964,20 @@
#endif
#ifdef VK_EXT_host_image_copy
VkResult vkCopyMemoryToImageEXT(VkDevice device,
- const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo,
+ const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo,
uint32_t doLock);
VkResult vkCopyImageToMemoryEXT(VkDevice device,
- const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo,
+ const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo,
uint32_t doLock);
VkResult vkCopyImageToImageEXT(VkDevice device,
- const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo,
+ const VkCopyImageToImageInfo* pCopyImageToImageInfo,
uint32_t doLock);
VkResult vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount,
- const VkHostImageLayoutTransitionInfoEXT* pTransitions,
+ const VkHostImageLayoutTransitionInfo* pTransitions,
uint32_t doLock);
void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout, uint32_t doLock);
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout, uint32_t doLock);
#endif
#ifdef VK_EXT_private_data
VkResult vkCreatePrivateDataSlotEXT(VkDevice device,
diff --git a/src/gfxstream/guest/vulkan_enc/func_table.cpp b/src/gfxstream/guest/vulkan_enc/func_table.cpp
index 2d23aa8..cba48fd 100644
--- a/src/gfxstream/guest/vulkan_enc/func_table.cpp
+++ b/src/gfxstream/guest/vulkan_enc/func_table.cpp
@@ -42,7 +42,7 @@
// required extensions, but the approach will be to
// implement them completely on the guest side.
#undef VK_KHR_android_surface
-#if defined(LINUX_GUEST_BUILD) || defined(__Fuchsia__)
+#if defined(LINUX_GUEST_BUILD) || DETECT_OS_FUCHSIA || DETECT_OS_WINDOWS
#undef VK_ANDROID_native_buffer
#endif
#ifdef VK_VERSION_1_0
@@ -2835,6 +2835,301 @@
}
}
#endif
+#ifdef VK_VERSION_1_4
+void gfxstream_vk_CmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern) {
+ MESA_TRACE_SCOPE("vkCmdSetLineStipple");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLineStipple(gfxstream_commandBuffer->internal_object, lineStippleFactor,
+ lineStipplePattern, true /* do lock */);
+ }
+}
+VkResult gfxstream_vk_MapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo,
+ void** ppData) {
+ MESA_TRACE_SCOPE("vkMapMemory2");
+ VkResult vkMapMemory2_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkMapMemory2_VkResult_return = vkEnc->vkMapMemory2(
+ gfxstream_device->internal_object, pMemoryMapInfo, ppData, true /* do lock */);
+ }
+ return vkMapMemory2_VkResult_return;
+}
+VkResult gfxstream_vk_UnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
+ MESA_TRACE_SCOPE("vkUnmapMemory2");
+ VkResult vkUnmapMemory2_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkUnmapMemory2_VkResult_return = vkEnc->vkUnmapMemory2(
+ gfxstream_device->internal_object, pMemoryUnmapInfo, true /* do lock */);
+ }
+ return vkUnmapMemory2_VkResult_return;
+}
+void gfxstream_vk_CmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkDeviceSize size,
+ VkIndexType indexType) {
+ MESA_TRACE_SCOPE("vkCmdBindIndexBuffer2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindIndexBuffer2(
+ gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer ? gfxstream_buffer->internal_object : VK_NULL_HANDLE, offset, size,
+ indexType, true /* do lock */);
+ }
+}
+void gfxstream_vk_GetRenderingAreaGranularity(VkDevice device,
+ const VkRenderingAreaInfo* pRenderingAreaInfo,
+ VkExtent2D* pGranularity) {
+ MESA_TRACE_SCOPE("vkGetRenderingAreaGranularity");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetRenderingAreaGranularity(gfxstream_device->internal_object, pRenderingAreaInfo,
+ pGranularity, true /* do lock */);
+ }
+}
+void gfxstream_vk_GetDeviceImageSubresourceLayout(VkDevice device,
+ const VkDeviceImageSubresourceInfo* pInfo,
+ VkSubresourceLayout2* pLayout) {
+ MESA_TRACE_SCOPE("vkGetDeviceImageSubresourceLayout");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSubresourceLayout(gfxstream_device->internal_object, pInfo, pLayout,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_GetImageSubresourceLayout2(VkDevice device, VkImage image,
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout) {
+ MESA_TRACE_SCOPE("vkGetImageSubresourceLayout2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout2(gfxstream_device->internal_object, image, pSubresource,
+ pLayout, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdPushDescriptorSet(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout, uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites) {
+ MESA_TRACE_SCOPE("vkCmdPushDescriptorSet");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkWriteDescriptorSet> internal_pDescriptorWrites(descriptorWriteCount);
+ std::vector<std::vector<VkDescriptorBufferInfo>> internal_VkWriteDescriptorSet_pBufferInfo;
+ for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+ internal_pDescriptorWrites[i] = pDescriptorWrites[i];
+ /* VkWriteDescriptorSet::pBufferInfo */
+ internal_VkWriteDescriptorSet_pBufferInfo.push_back(
+ std::vector<VkDescriptorBufferInfo>());
+ internal_VkWriteDescriptorSet_pBufferInfo[i].resize(
+ internal_pDescriptorWrites[i].descriptorCount);
+ for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+ if (internal_pDescriptorWrites[i].pBufferInfo) {
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j] =
+ internal_pDescriptorWrites[i].pBufferInfo[j];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer);
+ internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ internal_pDescriptorWrites[i].pBufferInfo =
+ internal_VkWriteDescriptorSet_pBufferInfo[i].data();
+ }
+ vkEnc->vkCmdPushDescriptorSet(gfxstream_commandBuffer->internal_object, pipelineBindPoint,
+ layout, set, descriptorWriteCount,
+ internal_pDescriptorWrites.data(), true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdPushDescriptorSetWithTemplate(
+ VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set, const void* pData) {
+ MESA_TRACE_SCOPE("vkCmdPushDescriptorSetWithTemplate");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdPushDescriptorSetWithTemplate(gfxstream_commandBuffer->internal_object,
+ descriptorUpdateTemplate, layout, set, pData,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdSetRenderingAttachmentLocations(
+ VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
+ MESA_TRACE_SCOPE("vkCmdSetRenderingAttachmentLocations");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetRenderingAttachmentLocations(gfxstream_commandBuffer->internal_object,
+ pLocationInfo, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdSetRenderingInputAttachmentIndices(
+ VkCommandBuffer commandBuffer,
+ const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
+ MESA_TRACE_SCOPE("vkCmdSetRenderingInputAttachmentIndices");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetRenderingInputAttachmentIndices(gfxstream_commandBuffer->internal_object,
+ pInputAttachmentIndexInfo,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdBindDescriptorSets2(VkCommandBuffer commandBuffer,
+ const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
+ MESA_TRACE_SCOPE("vkCmdBindDescriptorSets2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindDescriptorSets2(gfxstream_commandBuffer->internal_object,
+ pBindDescriptorSetsInfo, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdPushConstants2(VkCommandBuffer commandBuffer,
+ const VkPushConstantsInfo* pPushConstantsInfo) {
+ MESA_TRACE_SCOPE("vkCmdPushConstants2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdPushConstants2(gfxstream_commandBuffer->internal_object, pPushConstantsInfo,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdPushDescriptorSet2(VkCommandBuffer commandBuffer,
+ const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
+ MESA_TRACE_SCOPE("vkCmdPushDescriptorSet2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkPushDescriptorSetInfo> internal_pPushDescriptorSetInfo(1);
+ std::vector<std::vector<VkWriteDescriptorSet>>
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites;
+ std::vector<std::vector<VkDescriptorBufferInfo>> internal_VkWriteDescriptorSet_pBufferInfo;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pPushDescriptorSetInfo[i] = pPushDescriptorSetInfo[i];
+ /* VkPushDescriptorSetInfo::pDescriptorWrites */
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites.push_back(
+ std::vector<VkWriteDescriptorSet>());
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites[i].resize(
+ internal_pPushDescriptorSetInfo[i].descriptorWriteCount);
+ for (uint32_t j = 0; j < internal_pPushDescriptorSetInfo[i].descriptorWriteCount; ++j) {
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites[i][j] =
+ internal_pPushDescriptorSetInfo[i].pDescriptorWrites[j];
+ /* VkWriteDescriptorSet::pBufferInfo */
+ internal_VkWriteDescriptorSet_pBufferInfo.push_back(
+ std::vector<VkDescriptorBufferInfo>());
+ internal_VkWriteDescriptorSet_pBufferInfo[j].resize(
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites[i][j].descriptorCount);
+ for (uint32_t k = 0;
+ k < internal_VkPushDescriptorSetInfo_pDescriptorWrites[i][j].descriptorCount;
+ ++k) {
+ if (internal_VkPushDescriptorSetInfo_pDescriptorWrites[i][j].pBufferInfo) {
+ internal_VkWriteDescriptorSet_pBufferInfo[j][k] =
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites[i][j].pBufferInfo[k];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_VkWriteDescriptorSet_pBufferInfo[j][k].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkWriteDescriptorSet_pBufferInfo[j][k].buffer);
+ internal_VkWriteDescriptorSet_pBufferInfo[j][k].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites[i][j].pBufferInfo =
+ internal_VkWriteDescriptorSet_pBufferInfo[j].data();
+ }
+ internal_pPushDescriptorSetInfo[i].pDescriptorWrites =
+ internal_VkPushDescriptorSetInfo_pDescriptorWrites[i].data();
+ }
+ vkEnc->vkCmdPushDescriptorSet2(gfxstream_commandBuffer->internal_object,
+ internal_pPushDescriptorSetInfo.data(), true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdPushDescriptorSetWithTemplate2(
+ VkCommandBuffer commandBuffer,
+ const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
+ MESA_TRACE_SCOPE("vkCmdPushDescriptorSetWithTemplate2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdPushDescriptorSetWithTemplate2(gfxstream_commandBuffer->internal_object,
+ pPushDescriptorSetWithTemplateInfo,
+ true /* do lock */);
+ }
+}
+VkResult gfxstream_vk_CopyMemoryToImage(VkDevice device,
+ const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
+ MESA_TRACE_SCOPE("vkCopyMemoryToImage");
+ VkResult vkCopyMemoryToImage_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCopyMemoryToImage_VkResult_return = vkEnc->vkCopyMemoryToImage(
+ gfxstream_device->internal_object, pCopyMemoryToImageInfo, true /* do lock */);
+ }
+ return vkCopyMemoryToImage_VkResult_return;
+}
+VkResult gfxstream_vk_CopyImageToMemory(VkDevice device,
+ const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
+ MESA_TRACE_SCOPE("vkCopyImageToMemory");
+ VkResult vkCopyImageToMemory_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCopyImageToMemory_VkResult_return = vkEnc->vkCopyImageToMemory(
+ gfxstream_device->internal_object, pCopyImageToMemoryInfo, true /* do lock */);
+ }
+ return vkCopyImageToMemory_VkResult_return;
+}
+VkResult gfxstream_vk_CopyImageToImage(VkDevice device,
+ const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
+ MESA_TRACE_SCOPE("vkCopyImageToImage");
+ VkResult vkCopyImageToImage_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCopyImageToImage_VkResult_return = vkEnc->vkCopyImageToImage(
+ gfxstream_device->internal_object, pCopyImageToImageInfo, true /* do lock */);
+ }
+ return vkCopyImageToImage_VkResult_return;
+}
+VkResult gfxstream_vk_TransitionImageLayout(VkDevice device, uint32_t transitionCount,
+ const VkHostImageLayoutTransitionInfo* pTransitions) {
+ MESA_TRACE_SCOPE("vkTransitionImageLayout");
+ VkResult vkTransitionImageLayout_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkTransitionImageLayout_VkResult_return = vkEnc->vkTransitionImageLayout(
+ gfxstream_device->internal_object, transitionCount, pTransitions, true /* do lock */);
+ }
+ return vkTransitionImageLayout_VkResult_return;
+}
+#endif
#ifdef VK_KHR_android_surface
VkResult gfxstream_vk_CreateAndroidSurfaceKHR(VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
@@ -3649,31 +3944,6 @@
}
return vkQueueSubmit2KHR_VkResult_return;
}
-void gfxstream_vk_CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, uint32_t marker) {
- MESA_TRACE_SCOPE("vkCmdWriteBufferMarker2AMD");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdWriteBufferMarker2AMD(gfxstream_commandBuffer->internal_object, stage,
- gfxstream_dstBuffer->internal_object, dstOffset, marker,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData) {
- MESA_TRACE_SCOPE("vkGetQueueCheckpointData2NV");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- vkEnc->vkGetQueueCheckpointData2NV(gfxstream_queue->internal_object, pCheckpointDataCount,
- pCheckpointData, true /* do lock */);
- }
-}
#endif
#ifdef VK_KHR_copy_commands2
void gfxstream_vk_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
@@ -3827,7 +4097,7 @@
}
}
void gfxstream_vk_GetRenderingAreaGranularityKHR(VkDevice device,
- const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+ const VkRenderingAreaInfo* pRenderingAreaInfo,
VkExtent2D* pGranularity) {
MESA_TRACE_SCOPE("vkGetRenderingAreaGranularityKHR");
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
@@ -3839,8 +4109,8 @@
}
}
void gfxstream_vk_GetDeviceImageSubresourceLayoutKHR(VkDevice device,
- const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout) {
+ const VkDeviceImageSubresourceInfo* pInfo,
+ VkSubresourceLayout2* pLayout) {
MESA_TRACE_SCOPE("vkGetDeviceImageSubresourceLayoutKHR");
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
{
@@ -3850,8 +4120,8 @@
}
}
void gfxstream_vk_GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout) {
MESA_TRACE_SCOPE("vkGetImageSubresourceLayout2KHR");
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
{
@@ -4248,8 +4518,8 @@
}
#endif
#ifdef VK_EXT_host_image_copy
-VkResult gfxstream_vk_CopyMemoryToImageEXT(
- VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
+VkResult gfxstream_vk_CopyMemoryToImageEXT(VkDevice device,
+ const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
MESA_TRACE_SCOPE("vkCopyMemoryToImageEXT");
VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
@@ -4260,8 +4530,8 @@
}
return vkCopyMemoryToImageEXT_VkResult_return;
}
-VkResult gfxstream_vk_CopyImageToMemoryEXT(
- VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
+VkResult gfxstream_vk_CopyImageToMemoryEXT(VkDevice device,
+ const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
MESA_TRACE_SCOPE("vkCopyImageToMemoryEXT");
VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
@@ -4273,7 +4543,7 @@
return vkCopyImageToMemoryEXT_VkResult_return;
}
VkResult gfxstream_vk_CopyImageToImageEXT(VkDevice device,
- const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
+ const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
MESA_TRACE_SCOPE("vkCopyImageToImageEXT");
VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
@@ -4286,7 +4556,7 @@
}
VkResult gfxstream_vk_TransitionImageLayoutEXT(
VkDevice device, uint32_t transitionCount,
- const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
+ const VkHostImageLayoutTransitionInfo* pTransitions) {
MESA_TRACE_SCOPE("vkTransitionImageLayoutEXT");
VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
@@ -4298,8 +4568,8 @@
return vkTransitionImageLayoutEXT_VkResult_return;
}
void gfxstream_vk_GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
+ const VkImageSubresource2* pSubresource,
+ VkSubresourceLayout2* pLayout) {
MESA_TRACE_SCOPE("vkGetImageSubresourceLayout2EXT");
VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
{
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.cpp b/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
index 45070b8..f48c325 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -5707,10 +5707,10 @@
}
#endif
-#ifdef VK_KHR_dynamic_rendering
-void count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count) {
+#ifdef VK_VERSION_1_4
+void count_VkPhysicalDeviceVulkan14Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Features* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5720,16 +5720,32 @@
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- uint64_t cgen_var_0;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize),
- count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
}
-void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count) {
+void count_VkPhysicalDeviceVulkan14Properties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Properties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5739,14 +5755,476 @@
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- uint64_t cgen_var_0;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ *count += sizeof(VkBool32);
+ *count += sizeof(uint32_t);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(uint32_t);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessImageBehavior);
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pCopySrcLayouts) {
+ if (toCount) {
+ *count += toCount->copySrcLayoutCount * sizeof(VkImageLayout);
+ }
+ }
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pCopyDstLayouts) {
+ if (toCount) {
+ *count += toCount->copyDstLayoutCount * sizeof(VkImageLayout);
+ }
+ }
+ *count += VK_UUID_SIZE * sizeof(uint8_t);
+ *count += sizeof(VkBool32);
}
-void count_VkAttachmentSampleCountInfoAMD(uint32_t featureBits, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* toCount,
- size_t* count) {
+void count_VkDeviceQueueGlobalPriorityCreateInfo(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkQueueGlobalPriority);
+}
+
+void count_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkQueueFamilyGlobalPriorityProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityProperties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+ *count += VK_MAX_GLOBAL_PRIORITY_SIZE * sizeof(VkQueueGlobalPriority);
+}
+
+void count_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceShaderFloatControls2Features(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceLineRasterizationFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceLineRasterizationProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+}
+
+void count_VkPipelineRasterizationLineStateCreateInfo(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkLineRasterizationMode);
+ *count += sizeof(VkBool32);
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint16_t);
+}
+
+void count_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkVertexInputBindingDivisorDescription(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescription* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+}
+
+void count_VkPipelineVertexInputDivisorStateCreateInfo(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDivisorCount; ++i) {
+ count_VkVertexInputBindingDivisorDescription(
+ featureBits, rootType,
+ (const VkVertexInputBindingDivisorDescription*)(toCount->pVertexBindingDivisors +
+ i),
+ count);
+ }
+ }
+}
+
+void count_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceIndexTypeUint8Features(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8Features* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkMemoryMapInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryMapInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkMemoryMapFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkDeviceSize);
+ *count += sizeof(VkDeviceSize);
+}
+
+void count_VkMemoryUnmapInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryUnmapInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkMemoryUnmapFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+}
+
+void count_VkPhysicalDeviceMaintenance5Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceMaintenance5Properties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Properties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkRenderingAreaInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingAreaInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pColorAttachmentFormats) {
+ if (toCount) {
+ *count += toCount->colorAttachmentCount * sizeof(const VkFormat);
+ }
+ }
+ *count += sizeof(VkFormat);
+ *count += sizeof(VkFormat);
+}
+
+void count_VkImageSubresource2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresource2* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkImageSubresource(featureBits, rootType,
+ (VkImageSubresource*)(&toCount->imageSubresource), count);
+}
+
+void count_VkDeviceImageSubresourceInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkImageCreateInfo(featureBits, rootType, (const VkImageCreateInfo*)(toCount->pCreateInfo),
+ count);
+ count_VkImageSubresource2(featureBits, rootType,
+ (const VkImageSubresource2*)(toCount->pSubresource), count);
+}
+
+void count_VkSubresourceLayout2(uint32_t featureBits, VkStructureType rootType,
+ const VkSubresourceLayout2* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ count_VkSubresourceLayout(featureBits, rootType,
+ (VkSubresourceLayout*)(&toCount->subresourceLayout), count);
+}
+
+void count_VkPipelineCreateFlags2CreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkPipelineCreateFlags2);
+}
+
+void count_VkBufferUsageFlags2CreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBufferUsageFlags2);
+}
+
+void count_VkPhysicalDevicePushDescriptorProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+}
+
+void count_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkRenderingAttachmentLocationInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5759,16 +6237,15 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pColorAttachmentSamples) {
+ if (toCount->pColorAttachmentLocations) {
if (toCount) {
- *count += toCount->colorAttachmentCount * sizeof(const VkSampleCountFlagBits);
+ *count += toCount->colorAttachmentCount * sizeof(const uint32_t);
}
}
- *count += sizeof(VkSampleCountFlagBits);
}
-void count_VkMultiviewPerViewAttributesInfoNVX(uint32_t featureBits, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* toCount,
+void count_VkRenderingInputAttachmentIndexInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingInputAttachmentIndexInfo* toCount,
size_t* count) {
(void)featureBits;
(void)rootType;
@@ -5779,6 +6256,441 @@
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pColorAttachmentInputIndices) {
+ if (toCount) {
+ *count += toCount->colorAttachmentCount * sizeof(const uint32_t);
+ }
+ }
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pDepthInputAttachmentIndex) {
+ *count += sizeof(const uint32_t);
+ }
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pStencilInputAttachmentIndex) {
+ *count += sizeof(const uint32_t);
+ }
+}
+
+void count_VkPhysicalDeviceMaintenance6Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceMaintenance6Properties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Properties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+ *count += sizeof(uint32_t);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkBindMemoryStatus(uint32_t featureBits, VkStructureType rootType,
+ const VkBindMemoryStatus* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkResult);
+}
+
+void count_VkBindDescriptorSetsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkShaderStageFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ if (toCount->descriptorSetCount) {
+ *count += toCount->descriptorSetCount * 8;
+ }
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pDynamicOffsets) {
+ if (toCount) {
+ *count += toCount->dynamicOffsetCount * sizeof(const uint32_t);
+ }
+ }
+}
+
+void count_VkPushConstantsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPushConstantsInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkShaderStageFlags);
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ if (toCount) {
+ *count += toCount->size * sizeof(const uint8_t);
+ }
+}
+
+void count_VkPushDescriptorSetInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkShaderStageFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->descriptorWriteCount; ++i) {
+ count_VkWriteDescriptorSet(
+ featureBits, rootType,
+ (const VkWriteDescriptorSet*)(toCount->pDescriptorWrites + i), count);
+ }
+ }
+}
+
+void count_VkPushDescriptorSetWithTemplateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ uint64_t cgen_var_1;
+ *count += 1 * 8;
+ *count += sizeof(uint32_t);
+ *count += sizeof(const uint8_t);
+}
+
+void count_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDevicePipelineRobustnessFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDevicePipelineRobustnessProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessImageBehavior);
+}
+
+void count_VkPipelineRobustnessCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessBufferBehavior);
+ *count += sizeof(VkPipelineRobustnessImageBehavior);
+}
+
+void count_VkPhysicalDeviceHostImageCopyFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyFeatures* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkPhysicalDeviceHostImageCopyProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyProperties* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pCopySrcLayouts) {
+ if (toCount) {
+ *count += toCount->copySrcLayoutCount * sizeof(VkImageLayout);
+ }
+ }
+ *count += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ *count += 8;
+ if (toCount->pCopyDstLayouts) {
+ if (toCount) {
+ *count += toCount->copyDstLayoutCount * sizeof(VkImageLayout);
+ }
+ }
+ *count += VK_UUID_SIZE * sizeof(uint8_t);
+ *count += sizeof(VkBool32);
+}
+
+void count_VkMemoryToImageCopy(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryToImageCopy* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(const uint8_t);
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
+ count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
+ count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
+}
+
+void count_VkImageToMemoryCopy(uint32_t featureBits, VkStructureType rootType,
+ const VkImageToMemoryCopy* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(uint8_t);
+ *count += sizeof(uint32_t);
+ *count += sizeof(uint32_t);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
+ count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
+ count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
+}
+
+void count_VkCopyMemoryToImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkHostImageCopyFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkImageLayout);
+ *count += sizeof(uint32_t);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkMemoryToImageCopy(featureBits, rootType,
+ (const VkMemoryToImageCopy*)(toCount->pRegions + i), count);
+ }
+ }
+}
+
+void count_VkCopyImageToMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkHostImageCopyFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkImageLayout);
+ *count += sizeof(uint32_t);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkImageToMemoryCopy(featureBits, rootType,
+ (const VkImageToMemoryCopy*)(toCount->pRegions + i), count);
+ }
+ }
+}
+
+void count_VkCopyImageToImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageToImageInfo* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkHostImageCopyFlags);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkImageLayout);
+ uint64_t cgen_var_1;
+ *count += 1 * 8;
+ *count += sizeof(VkImageLayout);
+ *count += sizeof(uint32_t);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkImageCopy2(featureBits, rootType, (const VkImageCopy2*)(toCount->pRegions + i),
+ count);
+ }
+ }
+}
+
+void count_VkHostImageLayoutTransitionInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* toCount,
+ size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkImageLayout);
+ *count += sizeof(VkImageLayout);
+ count_VkImageSubresourceRange(featureBits, rootType,
+ (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
+}
+
+void count_VkSubresourceHostMemcpySize(uint32_t featureBits, VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ *count += sizeof(VkDeviceSize);
+}
+
+void count_VkHostImageCopyDevicePerformanceQuery(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkHostImageCopyDevicePerformanceQuery* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
}
@@ -6032,236 +6944,6 @@
}
#endif
-#ifdef VK_KHR_synchronization2
-void count_VkQueueFamilyCheckpointProperties2NV(uint32_t featureBits, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkPipelineStageFlags2);
-}
-
-void count_VkCheckpointData2NV(uint32_t featureBits, VkStructureType rootType,
- const VkCheckpointData2NV* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkPipelineStageFlags2);
- // WARNING PTR CHECK
- *count += 8;
- if (toCount->pCheckpointMarker) {
- *count += sizeof(uint8_t);
- }
-}
-
-#endif
-#ifdef VK_KHR_maintenance5
-void count_VkPhysicalDeviceMaintenance5FeaturesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5FeaturesKHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkBool32);
-}
-
-void count_VkPhysicalDeviceMaintenance5PropertiesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
-}
-
-void count_VkRenderingAreaInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(uint32_t);
- *count += sizeof(uint32_t);
- // WARNING PTR CHECK
- *count += 8;
- if (toCount->pColorAttachmentFormats) {
- if (toCount) {
- *count += toCount->colorAttachmentCount * sizeof(const VkFormat);
- }
- }
- *count += sizeof(VkFormat);
- *count += sizeof(VkFormat);
-}
-
-void count_VkImageSubresource2KHR(uint32_t featureBits, VkStructureType rootType,
- const VkImageSubresource2KHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageSubresource(featureBits, rootType,
- (VkImageSubresource*)(&toCount->imageSubresource), count);
-}
-
-void count_VkDeviceImageSubresourceInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageCreateInfo(featureBits, rootType, (const VkImageCreateInfo*)(toCount->pCreateInfo),
- count);
- count_VkImageSubresource2KHR(featureBits, rootType,
- (const VkImageSubresource2KHR*)(toCount->pSubresource), count);
-}
-
-void count_VkSubresourceLayout2KHR(uint32_t featureBits, VkStructureType rootType,
- const VkSubresourceLayout2KHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkSubresourceLayout(featureBits, rootType,
- (VkSubresourceLayout*)(&toCount->subresourceLayout), count);
-}
-
-void count_VkPipelineCreateFlags2CreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkPipelineCreateFlags2KHR);
-}
-
-void count_VkBufferUsageFlags2CreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkBufferUsageFlags2KHR);
-}
-
-#endif
-#ifdef VK_KHR_line_rasterization
-void count_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
-}
-
-void count_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(uint32_t);
-}
-
-void count_VkPipelineRasterizationLineStateCreateInfoKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkLineRasterizationModeKHR);
- *count += sizeof(VkBool32);
- *count += sizeof(uint32_t);
- *count += sizeof(uint16_t);
-}
-
-#endif
#ifdef VK_ANDROID_native_buffer
void count_VkNativeBufferUsage2ANDROID(uint32_t featureBits, VkStructureType rootType,
const VkNativeBufferUsage2ANDROID* toCount, size_t* count) {
@@ -6649,6 +7331,23 @@
count);
}
+void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count) {
+ (void)featureBits;
+ (void)rootType;
+ (void)toCount;
+ (void)count;
+ *count += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = toCount->sType;
+ }
+ count_extension_struct(featureBits, rootType, toCount->pNext, count);
+ uint64_t cgen_var_0;
+ *count += 1 * 8;
+ *count += sizeof(VkImageLayout);
+}
+
#endif
#ifdef VK_EXT_provoking_vertex
void count_VkPhysicalDeviceProvokingVertexFeaturesEXT(
@@ -6716,223 +7415,6 @@
}
#endif
-#ifdef VK_EXT_host_image_copy
-void count_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkBool32);
-}
-
-void count_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(uint32_t);
- // WARNING PTR CHECK
- *count += 8;
- if (toCount->pCopySrcLayouts) {
- if (toCount) {
- *count += toCount->copySrcLayoutCount * sizeof(VkImageLayout);
- }
- }
- *count += sizeof(uint32_t);
- // WARNING PTR CHECK
- *count += 8;
- if (toCount->pCopyDstLayouts) {
- if (toCount) {
- *count += toCount->copyDstLayoutCount * sizeof(VkImageLayout);
- }
- }
- *count += VK_UUID_SIZE * sizeof(uint8_t);
- *count += sizeof(VkBool32);
-}
-
-void count_VkMemoryToImageCopyEXT(uint32_t featureBits, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(const uint8_t);
- *count += sizeof(uint32_t);
- *count += sizeof(uint32_t);
- count_VkImageSubresourceLayers(featureBits, rootType,
- (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
- count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
- count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
-}
-
-void count_VkImageToMemoryCopyEXT(uint32_t featureBits, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(uint8_t);
- *count += sizeof(uint32_t);
- *count += sizeof(uint32_t);
- count_VkImageSubresourceLayers(featureBits, rootType,
- (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
- count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
- count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
-}
-
-void count_VkCopyMemoryToImageInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkHostImageCopyFlagsEXT);
- uint64_t cgen_var_0;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
- *count += sizeof(uint32_t);
- if (toCount) {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
- count_VkMemoryToImageCopyEXT(featureBits, rootType,
- (const VkMemoryToImageCopyEXT*)(toCount->pRegions + i),
- count);
- }
- }
-}
-
-void count_VkCopyImageToMemoryInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkHostImageCopyFlagsEXT);
- uint64_t cgen_var_0;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
- *count += sizeof(uint32_t);
- if (toCount) {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
- count_VkImageToMemoryCopyEXT(featureBits, rootType,
- (const VkImageToMemoryCopyEXT*)(toCount->pRegions + i),
- count);
- }
- }
-}
-
-void count_VkCopyImageToImageInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkHostImageCopyFlagsEXT);
- uint64_t cgen_var_0;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
- uint64_t cgen_var_1;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
- *count += sizeof(uint32_t);
- if (toCount) {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
- count_VkImageCopy2(featureBits, rootType, (const VkImageCopy2*)(toCount->pRegions + i),
- count);
- }
- }
-}
-
-void count_VkHostImageLayoutTransitionInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- uint64_t cgen_var_0;
- *count += 1 * 8;
- *count += sizeof(VkImageLayout);
- *count += sizeof(VkImageLayout);
- count_VkImageSubresourceRange(featureBits, rootType,
- (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
-}
-
-void count_VkSubresourceHostMemcpySizeEXT(uint32_t featureBits, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkDeviceSize);
-}
-
-void count_VkHostImageCopyDevicePerformanceQueryEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* toCount, size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(VkBool32);
- *count += sizeof(VkBool32);
-}
-
-#endif
#ifdef VK_EXT_texel_buffer_alignment
void count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
uint32_t featureBits, VkStructureType rootType,
@@ -8145,33 +8627,248 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ count_VkPhysicalDeviceVulkan14Features(
featureBits, rootType,
- reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(structExtension), count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ count_VkPhysicalDeviceVulkan14Properties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ count_VkDeviceQueueGlobalPriorityCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ count_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension),
count);
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ count_VkQueueFamilyGlobalPriorityProperties(
featureBits, rootType,
- reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ count_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension),
count);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- count_VkAttachmentSampleCountInfoAMD(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ count_VkPhysicalDeviceShaderFloatControls2Features(
featureBits, rootType,
- reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), count);
+ reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- count_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ count_VkPhysicalDeviceShaderExpectAssumeFeatures(
featureBits, rootType,
- reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension),
+ reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ count_VkPhysicalDeviceLineRasterizationFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ count_VkPhysicalDeviceLineRasterizationProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ count_VkPipelineRasterizationLineStateCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ count_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ count_VkPipelineVertexInputDivisorStateCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ count_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ count_VkPhysicalDeviceIndexTypeUint8Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ count_VkPhysicalDeviceMaintenance5Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ count_VkPhysicalDeviceMaintenance5Properties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ count_VkPipelineCreateFlags2CreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(structExtension), count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ count_VkBufferUsageFlags2CreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(structExtension), count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ count_VkPhysicalDevicePushDescriptorProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ count_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ count_VkRenderingAttachmentLocationInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(structExtension), count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ count_VkRenderingInputAttachmentIndexInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ count_VkPhysicalDeviceMaintenance6Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ count_VkPhysicalDeviceMaintenance6Properties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ count_VkBindMemoryStatus(featureBits, rootType,
+ reinterpret_cast<const VkBindMemoryStatus*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ count_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ count_VkPhysicalDevicePipelineRobustnessFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ count_VkPhysicalDevicePipelineRobustnessProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ count_VkPipelineRobustnessCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(structExtension), count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ count_VkPhysicalDeviceHostImageCopyFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ count_VkPhysicalDeviceHostImageCopyProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(structExtension),
+ count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ count_VkSubresourceHostMemcpySize(
+ featureBits, rootType,
+ reinterpret_cast<const VkSubresourceHostMemcpySize*>(structExtension), count);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ count_VkHostImageCopyDevicePerformanceQuery(
+ featureBits, rootType,
+ reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(structExtension),
count);
break;
}
@@ -8194,70 +8891,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- count_VkQueueFamilyCheckpointProperties2NV(
- featureBits, rootType,
- reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
- count);
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- count_VkPhysicalDeviceMaintenance5FeaturesKHR(
- featureBits, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- count_VkPhysicalDeviceMaintenance5PropertiesKHR(
- featureBits, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- count_VkPipelineCreateFlags2CreateInfoKHR(
- featureBits, rootType,
- reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- count_VkBufferUsageFlags2CreateInfoKHR(
- featureBits, rootType,
- reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension), count);
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- count_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- featureBits, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- count_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- featureBits, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- count_VkPipelineRasterizationLineStateCreateInfoKHR(
- featureBits, rootType,
- reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension),
- count);
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
count_VkNativeBufferANDROID(
@@ -8457,6 +9090,14 @@
}
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension),
+ count);
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -8494,36 +9135,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- count_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- featureBits, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- count_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- featureBits, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
- structExtension),
- count);
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- count_VkSubresourceHostMemcpySizeEXT(
- featureBits, rootType,
- reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension), count);
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- count_VkHostImageCopyDevicePerformanceQueryEXT(
- featureBits, rootType,
- reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension),
- count);
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.h b/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.h
index 1e5a5a9..cf62979 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.h
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_counting_guest.h
@@ -1032,6 +1032,196 @@
size_t* count);
#endif
+#ifdef VK_VERSION_1_4
+void count_VkPhysicalDeviceVulkan14Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Features* toCount,
+ size_t* count);
+
+void count_VkPhysicalDeviceVulkan14Properties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Properties* toCount,
+ size_t* count);
+
+void count_VkDeviceQueueGlobalPriorityCreateInfo(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfo* toCount, size_t* count);
+
+void count_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* toCount, size_t* count);
+
+void count_VkQueueFamilyGlobalPriorityProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityProperties* toCount, size_t* count);
+
+void count_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDeviceShaderFloatControls2Features(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* toCount, size_t* count);
+
+void count_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDeviceLineRasterizationFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDeviceLineRasterizationProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* toCount, size_t* count);
+
+void count_VkPipelineRasterizationLineStateCreateInfo(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* toCount, size_t* count);
+
+void count_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* toCount, size_t* count);
+
+void count_VkVertexInputBindingDivisorDescription(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescription* toCount, size_t* count);
+
+void count_VkPipelineVertexInputDivisorStateCreateInfo(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* toCount, size_t* count);
+
+void count_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDeviceIndexTypeUint8Features(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8Features* toCount, size_t* count);
+
+void count_VkMemoryMapInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryMapInfo* toCount, size_t* count);
+
+void count_VkMemoryUnmapInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryUnmapInfo* toCount, size_t* count);
+
+void count_VkPhysicalDeviceMaintenance5Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* toCount,
+ size_t* count);
+
+void count_VkPhysicalDeviceMaintenance5Properties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Properties* toCount, size_t* count);
+
+void count_VkRenderingAreaInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingAreaInfo* toCount, size_t* count);
+
+void count_VkImageSubresource2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresource2* toCount, size_t* count);
+
+void count_VkDeviceImageSubresourceInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* toCount, size_t* count);
+
+void count_VkSubresourceLayout2(uint32_t featureBits, VkStructureType rootType,
+ const VkSubresourceLayout2* toCount, size_t* count);
+
+void count_VkPipelineCreateFlags2CreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* toCount,
+ size_t* count);
+
+void count_VkBufferUsageFlags2CreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* toCount,
+ size_t* count);
+
+void count_VkPhysicalDevicePushDescriptorProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* toCount, size_t* count);
+
+void count_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* toCount, size_t* count);
+
+void count_VkRenderingAttachmentLocationInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* toCount,
+ size_t* count);
+
+void count_VkRenderingInputAttachmentIndexInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingInputAttachmentIndexInfo* toCount,
+ size_t* count);
+
+void count_VkPhysicalDeviceMaintenance6Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* toCount,
+ size_t* count);
+
+void count_VkPhysicalDeviceMaintenance6Properties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Properties* toCount, size_t* count);
+
+void count_VkBindMemoryStatus(uint32_t featureBits, VkStructureType rootType,
+ const VkBindMemoryStatus* toCount, size_t* count);
+
+void count_VkBindDescriptorSetsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* toCount, size_t* count);
+
+void count_VkPushConstantsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPushConstantsInfo* toCount, size_t* count);
+
+void count_VkPushDescriptorSetInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* toCount, size_t* count);
+
+void count_VkPushDescriptorSetWithTemplateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* toCount,
+ size_t* count);
+
+void count_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDevicePipelineRobustnessFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDevicePipelineRobustnessProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* toCount, size_t* count);
+
+void count_VkPipelineRobustnessCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* toCount,
+ size_t* count);
+
+void count_VkPhysicalDeviceHostImageCopyFeatures(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyFeatures* toCount, size_t* count);
+
+void count_VkPhysicalDeviceHostImageCopyProperties(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyProperties* toCount, size_t* count);
+
+void count_VkMemoryToImageCopy(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryToImageCopy* toCount, size_t* count);
+
+void count_VkImageToMemoryCopy(uint32_t featureBits, VkStructureType rootType,
+ const VkImageToMemoryCopy* toCount, size_t* count);
+
+void count_VkCopyMemoryToImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* toCount, size_t* count);
+
+void count_VkCopyImageToMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* toCount, size_t* count);
+
+void count_VkCopyImageToImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageToImageInfo* toCount, size_t* count);
+
+void count_VkHostImageLayoutTransitionInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* toCount,
+ size_t* count);
+
+void count_VkSubresourceHostMemcpySize(uint32_t featureBits, VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* toCount, size_t* count);
+
+void count_VkHostImageCopyDevicePerformanceQuery(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkHostImageCopyDevicePerformanceQuery* toCount, size_t* count);
+
+#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(count_VkRenderingInfo, count_VkRenderingInfoKHR)
@@ -1045,24 +1235,6 @@
DEFINE_ALIAS_FUNCTION(count_VkCommandBufferInheritanceRenderingInfo,
count_VkCommandBufferInheritanceRenderingInfoKHR)
-void count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count);
-
-void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count);
-
-void count_VkAttachmentSampleCountInfoAMD(uint32_t featureBits, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* toCount,
- size_t* count);
-
-DEFINE_ALIAS_FUNCTION(count_VkAttachmentSampleCountInfoAMD, count_VkAttachmentSampleCountInfoNV)
-
-void count_VkMultiviewPerViewAttributesInfoNVX(uint32_t featureBits, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* toCount,
- size_t* count);
-
#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceFeatures2, count_VkPhysicalDeviceFeatures2KHR)
@@ -1366,13 +1538,6 @@
DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSynchronization2Features,
count_VkPhysicalDeviceSynchronization2FeaturesKHR)
-void count_VkQueueFamilyCheckpointProperties2NV(uint32_t featureBits, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* toCount,
- size_t* count);
-
-void count_VkCheckpointData2NV(uint32_t featureBits, VkStructureType rootType,
- const VkCheckpointData2NV* toCount, size_t* count);
-
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
@@ -1422,48 +1587,35 @@
#endif
#ifdef VK_KHR_maintenance5
-void count_VkPhysicalDeviceMaintenance5FeaturesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5FeaturesKHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMaintenance5Features,
+ count_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void count_VkPhysicalDeviceMaintenance5PropertiesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMaintenance5Properties,
+ count_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void count_VkRenderingAreaInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkRenderingAreaInfo, count_VkRenderingAreaInfoKHR)
-void count_VkImageSubresource2KHR(uint32_t featureBits, VkStructureType rootType,
- const VkImageSubresource2KHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkDeviceImageSubresourceInfo, count_VkDeviceImageSubresourceInfoKHR)
-void count_VkDeviceImageSubresourceInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* toCount,
- size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkImageSubresource2, count_VkImageSubresource2KHR)
-void count_VkSubresourceLayout2KHR(uint32_t featureBits, VkStructureType rootType,
- const VkSubresourceLayout2KHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkSubresourceLayout2, count_VkSubresourceLayout2KHR)
-void count_VkPipelineCreateFlags2CreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* toCount,
- size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPipelineCreateFlags2CreateInfo,
+ count_VkPipelineCreateFlags2CreateInfoKHR)
-void count_VkBufferUsageFlags2CreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* toCount,
- size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkBufferUsageFlags2CreateInfo, count_VkBufferUsageFlags2CreateInfoKHR)
#endif
#ifdef VK_KHR_line_rasterization
-void count_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceLineRasterizationFeatures,
+ count_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void count_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceLineRasterizationProperties,
+ count_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void count_VkPipelineRasterizationLineStateCreateInfoKHR(
- uint32_t featureBits, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPipelineRasterizationLineStateCreateInfo,
+ count_VkPipelineRasterizationLineStateCreateInfoKHR)
#endif
#ifdef VK_ANDROID_native_buffer
@@ -1564,13 +1716,13 @@
uint32_t featureBits, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount, size_t* count);
-DEFINE_ALIAS_FUNCTION(count_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(count_VkVertexInputBindingDivisorDescription,
count_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(count_VkPipelineVertexInputDivisorStateCreateInfo,
count_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVertexAttributeDivisorFeatures,
count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
#endif
@@ -1594,6 +1746,10 @@
uint32_t featureBits, VkStructureType rootType,
const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount, size_t* count);
+void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count);
+
#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceScalarBlockLayoutFeatures,
@@ -1630,18 +1786,18 @@
#endif
#ifdef VK_EXT_line_rasterization
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceLineRasterizationFeatures,
count_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceLineRasterizationProperties,
count_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(count_VkPipelineRasterizationLineStateCreateInfo,
count_VkPipelineRasterizationLineStateCreateInfoEXT)
#endif
#ifdef VK_EXT_index_type_uint8
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceIndexTypeUint8Features,
count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
#endif
@@ -1652,44 +1808,33 @@
#endif
#ifdef VK_EXT_host_image_copy
-void count_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceHostImageCopyFeatures,
+ count_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void count_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceHostImageCopyProperties,
+ count_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void count_VkMemoryToImageCopyEXT(uint32_t featureBits, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkMemoryToImageCopy, count_VkMemoryToImageCopyEXT)
-void count_VkImageToMemoryCopyEXT(uint32_t featureBits, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkImageToMemoryCopy, count_VkImageToMemoryCopyEXT)
-void count_VkCopyMemoryToImageInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkCopyMemoryToImageInfo, count_VkCopyMemoryToImageInfoEXT)
-void count_VkCopyImageToMemoryInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkCopyImageToMemoryInfo, count_VkCopyImageToMemoryInfoEXT)
-void count_VkCopyImageToImageInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkCopyImageToImageInfo, count_VkCopyImageToImageInfoEXT)
-void count_VkHostImageLayoutTransitionInfoEXT(uint32_t featureBits, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* toCount,
- size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkHostImageLayoutTransitionInfo,
+ count_VkHostImageLayoutTransitionInfoEXT)
-void count_VkSubresourceHostMemcpySizeEXT(uint32_t featureBits, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* toCount,
- size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkSubresourceHostMemcpySize, count_VkSubresourceHostMemcpySizeEXT)
-void count_VkHostImageCopyDevicePerformanceQueryEXT(
- uint32_t featureBits, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* toCount, size_t* count);
+DEFINE_ALIAS_FUNCTION(count_VkHostImageCopyDevicePerformanceQuery,
+ count_VkHostImageCopyDevicePerformanceQueryEXT)
-DEFINE_ALIAS_FUNCTION(count_VkSubresourceLayout2KHR, count_VkSubresourceLayout2EXT)
+DEFINE_ALIAS_FUNCTION(count_VkSubresourceLayout2, count_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(count_VkImageSubresource2KHR, count_VkImageSubresource2EXT)
+DEFINE_ALIAS_FUNCTION(count_VkImageSubresource2, count_VkImageSubresource2EXT)
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index 52d8a45..252bcf2 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -92,7 +92,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -113,7 +113,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -134,7 +134,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -186,7 +186,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -209,7 +209,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -250,7 +250,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -295,7 +295,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -418,7 +418,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -444,7 +444,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -512,7 +512,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -553,7 +553,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -574,7 +574,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -688,7 +688,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -778,7 +778,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -799,7 +799,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -820,7 +820,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -841,7 +841,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -862,7 +862,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -889,7 +889,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -910,7 +910,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -951,7 +951,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -977,7 +977,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1004,7 +1004,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1062,7 +1062,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1095,7 +1095,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1135,7 +1135,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1185,7 +1185,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1207,7 +1207,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1236,7 +1236,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1281,7 +1281,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1303,7 +1303,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1338,7 +1338,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1370,7 +1370,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1406,7 +1406,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1433,7 +1433,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1547,7 +1547,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1585,7 +1585,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1606,7 +1606,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1650,7 +1650,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1684,7 +1684,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1724,7 +1724,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1758,7 +1758,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1824,7 +1824,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1914,7 +1914,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1972,7 +1972,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -1994,7 +1994,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2016,7 +2016,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2038,7 +2038,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2184,7 +2184,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2221,7 +2221,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2243,7 +2243,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2264,7 +2264,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2286,7 +2286,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2308,7 +2308,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2330,7 +2330,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2352,7 +2352,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2374,7 +2374,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2408,7 +2408,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2430,7 +2430,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2468,7 +2468,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2490,7 +2490,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2517,7 +2517,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2556,7 +2556,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2580,7 +2580,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2607,7 +2607,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2629,7 +2629,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2651,7 +2651,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2672,7 +2672,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2696,7 +2696,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2721,7 +2721,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2745,7 +2745,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2768,7 +2768,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2792,7 +2792,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2816,7 +2816,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2838,7 +2838,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2862,7 +2862,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2887,7 +2887,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2911,7 +2911,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2933,7 +2933,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2964,7 +2964,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -2999,7 +2999,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3022,7 +3022,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3044,7 +3044,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3081,7 +3081,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3103,7 +3103,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3126,7 +3126,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3148,7 +3148,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3171,7 +3171,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3192,7 +3192,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3213,7 +3213,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3235,7 +3235,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3259,7 +3259,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3281,7 +3281,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3303,7 +3303,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3326,7 +3326,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3349,7 +3349,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3379,7 +3379,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3422,7 +3422,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3444,7 +3444,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3469,7 +3469,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3491,7 +3491,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3516,7 +3516,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3541,7 +3541,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3563,7 +3563,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3585,7 +3585,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3607,7 +3607,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3629,7 +3629,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3651,7 +3651,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3673,7 +3673,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3695,7 +3695,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3717,7 +3717,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3739,7 +3739,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3761,7 +3761,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3784,7 +3784,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3808,7 +3808,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3830,7 +3830,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3855,7 +3855,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3884,7 +3884,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3910,7 +3910,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3937,7 +3937,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3959,7 +3959,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -3980,7 +3980,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4052,7 +4052,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4074,7 +4074,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4137,7 +4137,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4158,7 +4158,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4180,7 +4180,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4202,7 +4202,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4229,7 +4229,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4252,7 +4252,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4274,7 +4274,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4297,7 +4297,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4325,7 +4325,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4348,7 +4348,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4371,7 +4371,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4399,7 +4399,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4421,7 +4421,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4452,7 +4452,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4475,7 +4475,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4497,7 +4497,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4519,7 +4519,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4542,7 +4542,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4565,7 +4565,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4588,7 +4588,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4610,7 +4610,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4637,7 +4637,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4672,7 +4672,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4700,7 +4700,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4723,7 +4723,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4746,7 +4746,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4768,7 +4768,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4790,7 +4790,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4812,7 +4812,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4835,7 +4835,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4858,7 +4858,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4880,7 +4880,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4902,7 +4902,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4933,7 +4933,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4964,7 +4964,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -4987,7 +4987,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5009,7 +5009,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5031,7 +5031,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5054,7 +5054,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5076,7 +5076,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5100,7 +5100,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5122,7 +5122,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5152,7 +5152,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5196,7 +5196,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5218,7 +5218,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5245,7 +5245,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5267,7 +5267,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5289,7 +5289,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5311,7 +5311,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5334,7 +5334,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5355,7 +5355,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5377,7 +5377,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5398,7 +5398,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5421,7 +5421,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5480,7 +5480,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5502,7 +5502,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5523,7 +5523,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5585,7 +5585,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5608,7 +5608,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5630,7 +5630,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5651,7 +5651,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5672,7 +5672,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5705,7 +5705,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5733,7 +5733,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5766,7 +5766,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5792,7 +5792,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5826,7 +5826,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5859,7 +5859,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5892,7 +5892,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5925,7 +5925,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5953,7 +5953,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -5988,7 +5988,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6011,7 +6011,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6034,7 +6034,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6057,7 +6057,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6080,7 +6080,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6102,7 +6102,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6129,7 +6129,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6152,7 +6152,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6174,7 +6174,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6196,7 +6196,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6246,7 +6246,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6274,7 +6274,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6296,7 +6296,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6324,7 +6324,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6347,7 +6347,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6370,7 +6370,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6391,7 +6391,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6413,7 +6413,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6435,7 +6435,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6457,7 +6457,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6485,7 +6485,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6502,11 +6502,89 @@
}
#endif
-#ifdef VK_KHR_dynamic_rendering
-void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+void deepcopy_VkPhysicalDeviceVulkan14Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Features* from,
+ VkPhysicalDeviceVulkan14Features* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceVulkan14Properties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Properties* from,
+ VkPhysicalDeviceVulkan14Properties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pCopySrcLayouts = nullptr;
+ if (from->pCopySrcLayouts) {
+ to->pCopySrcLayouts = (VkImageLayout*)alloc->dupArray(
+ from->pCopySrcLayouts, from->copySrcLayoutCount * sizeof(VkImageLayout));
+ }
+ to->pCopyDstLayouts = nullptr;
+ if (from->pCopyDstLayouts) {
+ to->pCopyDstLayouts = (VkImageLayout*)alloc->dupArray(
+ from->pCopyDstLayouts, from->copyDstLayoutCount * sizeof(VkImageLayout));
+ }
+ memcpy(to->optimalTilingLayoutUUID, from->optimalTilingLayoutUUID,
+ VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfo(
+ Allocator* alloc, VkStructureType rootType, const VkDeviceQueueGlobalPriorityCreateInfo* from,
+ VkDeviceQueueGlobalPriorityCreateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeatures(
Allocator* alloc, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* from,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* to) {
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* from,
+ VkPhysicalDeviceGlobalPriorityQueryFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6516,7 +6594,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6524,14 +6602,36 @@
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize,
- (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
}
-void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+void deepcopy_VkQueueFamilyGlobalPriorityProperties(
+ Allocator* alloc, VkStructureType rootType, const VkQueueFamilyGlobalPriorityProperties* from,
+ VkQueueFamilyGlobalPriorityProperties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ memcpy(to->priorities, from->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE * sizeof(VkQueueGlobalPriority));
+}
+
+void deepcopy_VkPhysicalDeviceShaderSubgroupRotateFeatures(
Allocator* alloc, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* to) {
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* from,
+ VkPhysicalDeviceShaderSubgroupRotateFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6541,7 +6641,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6551,9 +6651,10 @@
}
}
-void deepcopy_VkAttachmentSampleCountInfoAMD(Allocator* alloc, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* from,
- VkAttachmentSampleCountInfoAMD* to) {
+void deepcopy_VkPhysicalDeviceShaderFloatControls2Features(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* from,
+ VkPhysicalDeviceShaderFloatControls2Features* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6563,7 +6664,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6571,17 +6672,12 @@
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- to->pColorAttachmentSamples = nullptr;
- if (from->pColorAttachmentSamples) {
- to->pColorAttachmentSamples = (VkSampleCountFlagBits*)alloc->dupArray(
- from->pColorAttachmentSamples,
- from->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
- }
}
-void deepcopy_VkMultiviewPerViewAttributesInfoNVX(Allocator* alloc, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* from,
- VkMultiviewPerViewAttributesInfoNVX* to) {
+void deepcopy_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* from,
+ VkPhysicalDeviceShaderExpectAssumeFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6591,7 +6687,1097 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceLineRasterizationFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* from,
+ VkPhysicalDeviceLineRasterizationFeatures* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceLineRasterizationProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* from,
+ VkPhysicalDeviceLineRasterizationProperties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineRasterizationLineStateCreateInfo(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* from,
+ VkPipelineRasterizationLineStateCreateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* from,
+ VkPhysicalDeviceVertexAttributeDivisorProperties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkVertexInputBindingDivisorDescription(
+ Allocator* alloc, VkStructureType rootType, const VkVertexInputBindingDivisorDescription* from,
+ VkVertexInputBindingDivisorDescription* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+}
+
+void deepcopy_VkPipelineVertexInputDivisorStateCreateInfo(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* from,
+ VkPipelineVertexInputDivisorStateCreateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ if (from) {
+ to->pVertexBindingDivisors = nullptr;
+ if (from->pVertexBindingDivisors) {
+ to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescription*)alloc->alloc(
+ from->vertexBindingDivisorCount *
+ sizeof(const VkVertexInputBindingDivisorDescription));
+ to->vertexBindingDivisorCount = from->vertexBindingDivisorCount;
+ for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDivisorCount; ++i) {
+ deepcopy_VkVertexInputBindingDivisorDescription(
+ alloc, rootType, from->pVertexBindingDivisors + i,
+ (VkVertexInputBindingDivisorDescription*)(to->pVertexBindingDivisors + i));
+ }
+ }
+ }
+}
+
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* from,
+ VkPhysicalDeviceVertexAttributeDivisorFeatures* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceIndexTypeUint8Features(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceIndexTypeUint8Features* from,
+ VkPhysicalDeviceIndexTypeUint8Features* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryMapInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryMapInfo* from, VkMemoryMapInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkMemoryUnmapInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryUnmapInfo* from, VkMemoryUnmapInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance5Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* from,
+ VkPhysicalDeviceMaintenance5Features* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance5Properties(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance5Properties* from,
+ VkPhysicalDeviceMaintenance5Properties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkRenderingAreaInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingAreaInfo* from, VkRenderingAreaInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pColorAttachmentFormats = nullptr;
+ if (from->pColorAttachmentFormats) {
+ to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
+ from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+ }
+}
+
+void deepcopy_VkImageSubresource2(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresource2* from, VkImageSubresource2* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkImageSubresource(alloc, rootType, &from->imageSubresource,
+ (VkImageSubresource*)(&to->imageSubresource));
+}
+
+void deepcopy_VkDeviceImageSubresourceInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* from,
+ VkDeviceImageSubresourceInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pCreateInfo = nullptr;
+ if (from->pCreateInfo) {
+ to->pCreateInfo = (VkImageCreateInfo*)alloc->alloc(sizeof(const VkImageCreateInfo));
+ deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo,
+ (VkImageCreateInfo*)(to->pCreateInfo));
+ }
+ to->pSubresource = nullptr;
+ if (from->pSubresource) {
+ to->pSubresource = (VkImageSubresource2*)alloc->alloc(sizeof(const VkImageSubresource2));
+ deepcopy_VkImageSubresource2(alloc, rootType, from->pSubresource,
+ (VkImageSubresource2*)(to->pSubresource));
+ }
+}
+
+void deepcopy_VkSubresourceLayout2(Allocator* alloc, VkStructureType rootType,
+ const VkSubresourceLayout2* from, VkSubresourceLayout2* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkSubresourceLayout(alloc, rootType, &from->subresourceLayout,
+ (VkSubresourceLayout*)(&to->subresourceLayout));
+}
+
+void deepcopy_VkPipelineCreateFlags2CreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* from,
+ VkPipelineCreateFlags2CreateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBufferUsageFlags2CreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* from,
+ VkBufferUsageFlags2CreateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDevicePushDescriptorProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* from,
+ VkPhysicalDevicePushDescriptorProperties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* from,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkRenderingAttachmentLocationInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* from,
+ VkRenderingAttachmentLocationInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pColorAttachmentLocations = nullptr;
+ if (from->pColorAttachmentLocations) {
+ to->pColorAttachmentLocations = (uint32_t*)alloc->dupArray(
+ from->pColorAttachmentLocations, from->colorAttachmentCount * sizeof(const uint32_t));
+ }
+}
+
+void deepcopy_VkRenderingInputAttachmentIndexInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingInputAttachmentIndexInfo* from,
+ VkRenderingInputAttachmentIndexInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pColorAttachmentInputIndices = nullptr;
+ if (from->pColorAttachmentInputIndices) {
+ to->pColorAttachmentInputIndices =
+ (uint32_t*)alloc->dupArray(from->pColorAttachmentInputIndices,
+ from->colorAttachmentCount * sizeof(const uint32_t));
+ }
+ to->pDepthInputAttachmentIndex = nullptr;
+ if (from->pDepthInputAttachmentIndex) {
+ to->pDepthInputAttachmentIndex =
+ (uint32_t*)alloc->dupArray(from->pDepthInputAttachmentIndex, sizeof(const uint32_t));
+ }
+ to->pStencilInputAttachmentIndex = nullptr;
+ if (from->pStencilInputAttachmentIndex) {
+ to->pStencilInputAttachmentIndex =
+ (uint32_t*)alloc->dupArray(from->pStencilInputAttachmentIndex, sizeof(const uint32_t));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance6Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* from,
+ VkPhysicalDeviceMaintenance6Features* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance6Properties(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance6Properties* from,
+ VkPhysicalDeviceMaintenance6Properties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkBindMemoryStatus(Allocator* alloc, VkStructureType rootType,
+ const VkBindMemoryStatus* from, VkBindMemoryStatus* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pResult = nullptr;
+ if (from->pResult) {
+ to->pResult = (VkResult*)alloc->dupArray(from->pResult, sizeof(VkResult));
+ }
+}
+
+void deepcopy_VkBindDescriptorSetsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* from,
+ VkBindDescriptorSetsInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pDescriptorSets = nullptr;
+ if (from->pDescriptorSets) {
+ to->pDescriptorSets = (VkDescriptorSet*)alloc->dupArray(
+ from->pDescriptorSets, from->descriptorSetCount * sizeof(const VkDescriptorSet));
+ }
+ to->pDynamicOffsets = nullptr;
+ if (from->pDynamicOffsets) {
+ to->pDynamicOffsets = (uint32_t*)alloc->dupArray(
+ from->pDynamicOffsets, from->dynamicOffsetCount * sizeof(const uint32_t));
+ }
+}
+
+void deepcopy_VkPushConstantsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPushConstantsInfo* from, VkPushConstantsInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pValues = nullptr;
+ if (from->pValues) {
+ to->pValues = (void*)alloc->dupArray(from->pValues, from->size * sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkPushDescriptorSetInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* from,
+ VkPushDescriptorSetInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ if (from) {
+ to->pDescriptorWrites = nullptr;
+ if (from->pDescriptorWrites) {
+ to->pDescriptorWrites = (VkWriteDescriptorSet*)alloc->alloc(
+ from->descriptorWriteCount * sizeof(const VkWriteDescriptorSet));
+ to->descriptorWriteCount = from->descriptorWriteCount;
+ for (uint32_t i = 0; i < (uint32_t)from->descriptorWriteCount; ++i) {
+ deepcopy_VkWriteDescriptorSet(alloc, rootType, from->pDescriptorWrites + i,
+ (VkWriteDescriptorSet*)(to->pDescriptorWrites + i));
+ }
+ }
+ }
+}
+
+void deepcopy_VkPushDescriptorSetWithTemplateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* from,
+ VkPushDescriptorSetWithTemplateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pData = nullptr;
+ if (from->pData) {
+ to->pData = (void*)alloc->dupArray(from->pData, sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* from,
+ VkPhysicalDevicePipelineProtectedAccessFeatures* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDevicePipelineRobustnessFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* from,
+ VkPhysicalDevicePipelineRobustnessFeatures* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDevicePipelineRobustnessProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* from,
+ VkPhysicalDevicePipelineRobustnessProperties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPipelineRobustnessCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* from,
+ VkPipelineRobustnessCreateInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceHostImageCopyFeatures(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostImageCopyFeatures* from,
+ VkPhysicalDeviceHostImageCopyFeatures* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceHostImageCopyProperties(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostImageCopyProperties* from,
+ VkPhysicalDeviceHostImageCopyProperties* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pCopySrcLayouts = nullptr;
+ if (from->pCopySrcLayouts) {
+ to->pCopySrcLayouts = (VkImageLayout*)alloc->dupArray(
+ from->pCopySrcLayouts, from->copySrcLayoutCount * sizeof(VkImageLayout));
+ }
+ to->pCopyDstLayouts = nullptr;
+ if (from->pCopyDstLayouts) {
+ to->pCopyDstLayouts = (VkImageLayout*)alloc->dupArray(
+ from->pCopyDstLayouts, from->copyDstLayoutCount * sizeof(VkImageLayout));
+ }
+ memcpy(to->optimalTilingLayoutUUID, from->optimalTilingLayoutUUID,
+ VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkMemoryToImageCopy(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryToImageCopy* from, VkMemoryToImageCopy* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pHostPointer = nullptr;
+ if (from->pHostPointer) {
+ to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(const uint8_t));
+ }
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+ (VkImageSubresourceLayers*)(&to->imageSubresource));
+ deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+ deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkImageToMemoryCopy(Allocator* alloc, VkStructureType rootType,
+ const VkImageToMemoryCopy* from, VkImageToMemoryCopy* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pHostPointer = nullptr;
+ if (from->pHostPointer) {
+ to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(uint8_t));
+ }
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+ (VkImageSubresourceLayers*)(&to->imageSubresource));
+ deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+ deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkCopyMemoryToImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* from,
+ VkCopyMemoryToImageInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ if (from) {
+ to->pRegions = nullptr;
+ if (from->pRegions) {
+ to->pRegions = (VkMemoryToImageCopy*)alloc->alloc(from->regionCount *
+ sizeof(const VkMemoryToImageCopy));
+ to->regionCount = from->regionCount;
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkMemoryToImageCopy(alloc, rootType, from->pRegions + i,
+ (VkMemoryToImageCopy*)(to->pRegions + i));
+ }
+ }
+ }
+}
+
+void deepcopy_VkCopyImageToMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* from,
+ VkCopyImageToMemoryInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ if (from) {
+ to->pRegions = nullptr;
+ if (from->pRegions) {
+ to->pRegions = (VkImageToMemoryCopy*)alloc->alloc(from->regionCount *
+ sizeof(const VkImageToMemoryCopy));
+ to->regionCount = from->regionCount;
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkImageToMemoryCopy(alloc, rootType, from->pRegions + i,
+ (VkImageToMemoryCopy*)(to->pRegions + i));
+ }
+ }
+ }
+}
+
+void deepcopy_VkCopyImageToImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageToImageInfo* from,
+ VkCopyImageToImageInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ if (from) {
+ to->pRegions = nullptr;
+ if (from->pRegions) {
+ to->pRegions =
+ (VkImageCopy2*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2));
+ to->regionCount = from->regionCount;
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkImageCopy2(alloc, rootType, from->pRegions + i,
+ (VkImageCopy2*)(to->pRegions + i));
+ }
+ }
+ }
+}
+
+void deepcopy_VkHostImageLayoutTransitionInfo(Allocator* alloc, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* from,
+ VkHostImageLayoutTransitionInfo* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
+ (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkSubresourceHostMemcpySize(Allocator* alloc, VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* from,
+ VkSubresourceHostMemcpySize* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkHostImageCopyDevicePerformanceQuery(
+ Allocator* alloc, VkStructureType rootType, const VkHostImageCopyDevicePerformanceQuery* from,
+ VkHostImageCopyDevicePerformanceQuery* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6615,7 +7801,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6637,7 +7823,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6688,7 +7874,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6724,7 +7910,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6745,7 +7931,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6770,7 +7956,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6791,7 +7977,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6813,7 +7999,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6837,7 +8023,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6867,7 +8053,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6894,7 +8080,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -6911,327 +8097,6 @@
}
#endif
-#ifdef VK_KHR_synchronization2
-void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* from,
- VkQueueFamilyCheckpointProperties2NV* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
- const VkCheckpointData2NV* from, VkCheckpointData2NV* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- to->pCheckpointMarker = nullptr;
- if (from->pCheckpointMarker) {
- to->pCheckpointMarker = (void*)alloc->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
- }
-}
-
-#endif
-#ifdef VK_KHR_maintenance5
-void deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR(
- Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance5FeaturesKHR* from,
- VkPhysicalDeviceMaintenance5FeaturesKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* from,
- VkPhysicalDeviceMaintenance5PropertiesKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkRenderingAreaInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* from,
- VkRenderingAreaInfoKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- to->pColorAttachmentFormats = nullptr;
- if (from->pColorAttachmentFormats) {
- to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
- from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
- }
-}
-
-void deepcopy_VkImageSubresource2KHR(Allocator* alloc, VkStructureType rootType,
- const VkImageSubresource2KHR* from,
- VkImageSubresource2KHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- deepcopy_VkImageSubresource(alloc, rootType, &from->imageSubresource,
- (VkImageSubresource*)(&to->imageSubresource));
-}
-
-void deepcopy_VkDeviceImageSubresourceInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* from,
- VkDeviceImageSubresourceInfoKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- to->pCreateInfo = nullptr;
- if (from->pCreateInfo) {
- to->pCreateInfo = (VkImageCreateInfo*)alloc->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo,
- (VkImageCreateInfo*)(to->pCreateInfo));
- }
- to->pSubresource = nullptr;
- if (from->pSubresource) {
- to->pSubresource =
- (VkImageSubresource2KHR*)alloc->alloc(sizeof(const VkImageSubresource2KHR));
- deepcopy_VkImageSubresource2KHR(alloc, rootType, from->pSubresource,
- (VkImageSubresource2KHR*)(to->pSubresource));
- }
-}
-
-void deepcopy_VkSubresourceLayout2KHR(Allocator* alloc, VkStructureType rootType,
- const VkSubresourceLayout2KHR* from,
- VkSubresourceLayout2KHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- deepcopy_VkSubresourceLayout(alloc, rootType, &from->subresourceLayout,
- (VkSubresourceLayout*)(&to->subresourceLayout));
-}
-
-void deepcopy_VkPipelineCreateFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* from,
- VkPipelineCreateFlags2CreateInfoKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkBufferUsageFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* from,
- VkBufferUsageFlags2CreateInfoKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-#endif
-#ifdef VK_KHR_line_rasterization
-void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* from,
- VkPhysicalDeviceLineRasterizationFeaturesKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* from,
- VkPhysicalDeviceLineRasterizationPropertiesKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkPipelineRasterizationLineStateCreateInfoKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* from,
- VkPipelineRasterizationLineStateCreateInfoKHR* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-#endif
#ifdef VK_ANDROID_native_buffer
void deepcopy_VkNativeBufferUsage2ANDROID(Allocator* alloc, VkStructureType rootType,
const VkNativeBufferUsage2ANDROID* from,
@@ -7252,7 +8117,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7280,7 +8145,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7303,7 +8168,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7328,7 +8193,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7351,7 +8216,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7374,7 +8239,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7399,7 +8264,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7422,7 +8287,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7454,7 +8319,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7490,7 +8355,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7518,7 +8383,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7546,7 +8411,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7580,7 +8445,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7610,7 +8475,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7648,7 +8513,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7673,7 +8538,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7696,7 +8561,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7723,7 +8588,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7735,6 +8600,29 @@
(VkAttachmentReference*)(&to->fragmentDensityMapAttachment));
}
+void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
+ VkRenderingFragmentDensityMapAttachmentInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
#endif
#ifdef VK_EXT_provoking_vertex
void deepcopy_VkPhysicalDeviceProvokingVertexFeaturesEXT(
@@ -7750,7 +8638,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7773,7 +8661,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7796,7 +8684,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -7821,298 +8709,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-#endif
-#ifdef VK_EXT_host_image_copy
-void deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* from,
- VkPhysicalDeviceHostImageCopyFeaturesEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* from,
- VkPhysicalDeviceHostImageCopyPropertiesEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- to->pCopySrcLayouts = nullptr;
- if (from->pCopySrcLayouts) {
- to->pCopySrcLayouts = (VkImageLayout*)alloc->dupArray(
- from->pCopySrcLayouts, from->copySrcLayoutCount * sizeof(VkImageLayout));
- }
- to->pCopyDstLayouts = nullptr;
- if (from->pCopyDstLayouts) {
- to->pCopyDstLayouts = (VkImageLayout*)alloc->dupArray(
- from->pCopyDstLayouts, from->copyDstLayoutCount * sizeof(VkImageLayout));
- }
- memcpy(to->optimalTilingLayoutUUID, from->optimalTilingLayoutUUID,
- VK_UUID_SIZE * sizeof(uint8_t));
-}
-
-void deepcopy_VkMemoryToImageCopyEXT(Allocator* alloc, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* from,
- VkMemoryToImageCopyEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- to->pHostPointer = nullptr;
- if (from->pHostPointer) {
- to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(const uint8_t));
- }
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
- (VkImageSubresourceLayers*)(&to->imageSubresource));
- deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
- deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
-}
-
-void deepcopy_VkImageToMemoryCopyEXT(Allocator* alloc, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* from,
- VkImageToMemoryCopyEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- to->pHostPointer = nullptr;
- if (from->pHostPointer) {
- to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(uint8_t));
- }
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
- (VkImageSubresourceLayers*)(&to->imageSubresource));
- deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
- deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
-}
-
-void deepcopy_VkCopyMemoryToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* from,
- VkCopyMemoryToImageInfoEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- if (from) {
- to->pRegions = nullptr;
- if (from->pRegions) {
- to->pRegions = (VkMemoryToImageCopyEXT*)alloc->alloc(
- from->regionCount * sizeof(const VkMemoryToImageCopyEXT));
- to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
- deepcopy_VkMemoryToImageCopyEXT(alloc, rootType, from->pRegions + i,
- (VkMemoryToImageCopyEXT*)(to->pRegions + i));
- }
- }
- }
-}
-
-void deepcopy_VkCopyImageToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* from,
- VkCopyImageToMemoryInfoEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- if (from) {
- to->pRegions = nullptr;
- if (from->pRegions) {
- to->pRegions = (VkImageToMemoryCopyEXT*)alloc->alloc(
- from->regionCount * sizeof(const VkImageToMemoryCopyEXT));
- to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
- deepcopy_VkImageToMemoryCopyEXT(alloc, rootType, from->pRegions + i,
- (VkImageToMemoryCopyEXT*)(to->pRegions + i));
- }
- }
- }
-}
-
-void deepcopy_VkCopyImageToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* from,
- VkCopyImageToImageInfoEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- if (from) {
- to->pRegions = nullptr;
- if (from->pRegions) {
- to->pRegions =
- (VkImageCopy2*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2));
- to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
- deepcopy_VkImageCopy2(alloc, rootType, from->pRegions + i,
- (VkImageCopy2*)(to->pRegions + i));
- }
- }
- }
-}
-
-void deepcopy_VkHostImageLayoutTransitionInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* from,
- VkHostImageLayoutTransitionInfoEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
- deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
- (VkImageSubresourceRange*)(&to->subresourceRange));
-}
-
-void deepcopy_VkSubresourceHostMemcpySizeEXT(Allocator* alloc, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* from,
- VkSubresourceHostMemcpySizeEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
-void deepcopy_VkHostImageCopyDevicePerformanceQueryEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* from,
- VkHostImageCopyDevicePerformanceQueryEXT* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8137,7 +8734,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8162,7 +8759,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8184,7 +8781,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8206,7 +8803,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8234,7 +8831,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8257,7 +8854,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8281,7 +8878,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8306,7 +8903,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8329,7 +8926,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8354,7 +8951,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8377,7 +8974,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8399,7 +8996,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8424,7 +9021,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8449,7 +9046,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8471,7 +9068,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8499,7 +9096,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8523,7 +9120,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8548,7 +9145,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8573,7 +9170,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8598,7 +9195,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8620,7 +9217,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8649,7 +9246,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8670,7 +9267,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8691,7 +9288,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -8716,7 +9313,7 @@
const void* from_pNext = from;
size_t pNext_size = 0u;
while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ from_pNext = static_cast<const VkBaseOutStructure*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
@@ -9554,37 +10151,265 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ deepcopy_VkPhysicalDeviceVulkan14Features(
alloc, rootType,
- reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkan14Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceVulkan14Properties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkan14Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ deepcopy_VkDeviceQueueGlobalPriorityCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension),
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension),
- reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ deepcopy_VkQueueFamilyGlobalPriorityProperties(
alloc, rootType,
- reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(structExtension),
+ reinterpret_cast<VkQueueFamilyGlobalPriorityProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension),
- reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- deepcopy_VkAttachmentSampleCountInfoAMD(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderFloatControls2Features(
alloc, rootType,
- reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension),
- reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- deepcopy_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderExpectAssumeFeatures(
alloc, rootType,
- reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension),
- reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ deepcopy_VkPhysicalDeviceLineRasterizationFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceLineRasterizationProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ deepcopy_VkPipelineRasterizationLineStateCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationLineStateCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ deepcopy_VkPipelineVertexInputDivisorStateCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension),
+ reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ deepcopy_VkPhysicalDeviceIndexTypeUint8Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ deepcopy_VkPhysicalDeviceMaintenance5Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceMaintenance5Properties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ deepcopy_VkPipelineCreateFlags2CreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(structExtension),
+ reinterpret_cast<VkPipelineCreateFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ deepcopy_VkBufferUsageFlags2CreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(structExtension),
+ reinterpret_cast<VkBufferUsageFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ deepcopy_VkPhysicalDevicePushDescriptorProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDevicePushDescriptorProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ deepcopy_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ deepcopy_VkRenderingAttachmentLocationInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(structExtension),
+ reinterpret_cast<VkRenderingAttachmentLocationInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ deepcopy_VkRenderingInputAttachmentIndexInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(structExtension),
+ reinterpret_cast<VkRenderingInputAttachmentIndexInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ deepcopy_VkPhysicalDeviceMaintenance6Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceMaintenance6Properties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ deepcopy_VkBindMemoryStatus(
+ alloc, rootType, reinterpret_cast<const VkBindMemoryStatus*>(structExtension),
+ reinterpret_cast<VkBindMemoryStatus*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ deepcopy_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ deepcopy_VkPhysicalDevicePipelineRobustnessFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ deepcopy_VkPhysicalDevicePipelineRobustnessProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ deepcopy_VkPipelineRobustnessCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(structExtension),
+ reinterpret_cast<VkPipelineRobustnessCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ deepcopy_VkPhysicalDeviceHostImageCopyFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceHostImageCopyProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ deepcopy_VkSubresourceHostMemcpySize(
+ alloc, rootType,
+ reinterpret_cast<const VkSubresourceHostMemcpySize*>(structExtension),
+ reinterpret_cast<VkSubresourceHostMemcpySize*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ deepcopy_VkHostImageCopyDevicePerformanceQuery(
+ alloc, rootType,
+ reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(structExtension),
+ reinterpret_cast<VkHostImageCopyDevicePerformanceQuery*>(structExtension_out));
break;
}
#endif
@@ -9607,74 +10432,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- deepcopy_VkQueueFamilyCheckpointProperties2NV(
- alloc, rootType,
- reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
- reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR(
- alloc, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension),
- reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR(
- alloc, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension),
- reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- deepcopy_VkPipelineCreateFlags2CreateInfoKHR(
- alloc, rootType,
- reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension),
- reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- deepcopy_VkBufferUsageFlags2CreateInfoKHR(
- alloc, rootType,
- reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension),
- reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- deepcopy_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- alloc, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension),
- reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- deepcopy_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- alloc, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension),
- reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- deepcopy_VkPipelineRasterizationLineStateCreateInfoKHR(
- alloc, rootType,
- reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension),
- reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension_out));
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
deepcopy_VkNativeBufferANDROID(
@@ -9892,6 +10649,15 @@
}
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -9932,37 +10698,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- alloc, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension),
- reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- alloc, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
- structExtension),
- reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- deepcopy_VkSubresourceHostMemcpySizeEXT(
- alloc, rootType,
- reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension),
- reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- deepcopy_VkHostImageCopyDevicePerformanceQueryEXT(
- alloc, rootType,
- reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension),
- reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h b/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
index df752c5..8affb21 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -1146,6 +1146,218 @@
VkDeviceImageMemoryRequirements* to);
#endif
+#ifdef VK_VERSION_1_4
+void deepcopy_VkPhysicalDeviceVulkan14Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Features* from,
+ VkPhysicalDeviceVulkan14Features* to);
+
+void deepcopy_VkPhysicalDeviceVulkan14Properties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Properties* from,
+ VkPhysicalDeviceVulkan14Properties* to);
+
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfo(
+ Allocator* alloc, VkStructureType rootType, const VkDeviceQueueGlobalPriorityCreateInfo* from,
+ VkDeviceQueueGlobalPriorityCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* from,
+ VkPhysicalDeviceGlobalPriorityQueryFeatures* to);
+
+void deepcopy_VkQueueFamilyGlobalPriorityProperties(
+ Allocator* alloc, VkStructureType rootType, const VkQueueFamilyGlobalPriorityProperties* from,
+ VkQueueFamilyGlobalPriorityProperties* to);
+
+void deepcopy_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* from,
+ VkPhysicalDeviceShaderSubgroupRotateFeatures* to);
+
+void deepcopy_VkPhysicalDeviceShaderFloatControls2Features(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* from,
+ VkPhysicalDeviceShaderFloatControls2Features* to);
+
+void deepcopy_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* from,
+ VkPhysicalDeviceShaderExpectAssumeFeatures* to);
+
+void deepcopy_VkPhysicalDeviceLineRasterizationFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* from,
+ VkPhysicalDeviceLineRasterizationFeatures* to);
+
+void deepcopy_VkPhysicalDeviceLineRasterizationProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* from,
+ VkPhysicalDeviceLineRasterizationProperties* to);
+
+void deepcopy_VkPipelineRasterizationLineStateCreateInfo(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* from,
+ VkPipelineRasterizationLineStateCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* from,
+ VkPhysicalDeviceVertexAttributeDivisorProperties* to);
+
+void deepcopy_VkVertexInputBindingDivisorDescription(
+ Allocator* alloc, VkStructureType rootType, const VkVertexInputBindingDivisorDescription* from,
+ VkVertexInputBindingDivisorDescription* to);
+
+void deepcopy_VkPipelineVertexInputDivisorStateCreateInfo(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* from,
+ VkPipelineVertexInputDivisorStateCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* from,
+ VkPhysicalDeviceVertexAttributeDivisorFeatures* to);
+
+void deepcopy_VkPhysicalDeviceIndexTypeUint8Features(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceIndexTypeUint8Features* from,
+ VkPhysicalDeviceIndexTypeUint8Features* to);
+
+void deepcopy_VkMemoryMapInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryMapInfo* from, VkMemoryMapInfo* to);
+
+void deepcopy_VkMemoryUnmapInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryUnmapInfo* from, VkMemoryUnmapInfo* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance5Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* from,
+ VkPhysicalDeviceMaintenance5Features* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance5Properties(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance5Properties* from,
+ VkPhysicalDeviceMaintenance5Properties* to);
+
+void deepcopy_VkRenderingAreaInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingAreaInfo* from, VkRenderingAreaInfo* to);
+
+void deepcopy_VkImageSubresource2(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresource2* from, VkImageSubresource2* to);
+
+void deepcopy_VkDeviceImageSubresourceInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* from,
+ VkDeviceImageSubresourceInfo* to);
+
+void deepcopy_VkSubresourceLayout2(Allocator* alloc, VkStructureType rootType,
+ const VkSubresourceLayout2* from, VkSubresourceLayout2* to);
+
+void deepcopy_VkPipelineCreateFlags2CreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* from,
+ VkPipelineCreateFlags2CreateInfo* to);
+
+void deepcopy_VkBufferUsageFlags2CreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* from,
+ VkBufferUsageFlags2CreateInfo* to);
+
+void deepcopy_VkPhysicalDevicePushDescriptorProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* from,
+ VkPhysicalDevicePushDescriptorProperties* to);
+
+void deepcopy_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* from,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* to);
+
+void deepcopy_VkRenderingAttachmentLocationInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* from,
+ VkRenderingAttachmentLocationInfo* to);
+
+void deepcopy_VkRenderingInputAttachmentIndexInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingInputAttachmentIndexInfo* from,
+ VkRenderingInputAttachmentIndexInfo* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance6Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* from,
+ VkPhysicalDeviceMaintenance6Features* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance6Properties(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance6Properties* from,
+ VkPhysicalDeviceMaintenance6Properties* to);
+
+void deepcopy_VkBindMemoryStatus(Allocator* alloc, VkStructureType rootType,
+ const VkBindMemoryStatus* from, VkBindMemoryStatus* to);
+
+void deepcopy_VkBindDescriptorSetsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* from,
+ VkBindDescriptorSetsInfo* to);
+
+void deepcopy_VkPushConstantsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPushConstantsInfo* from, VkPushConstantsInfo* to);
+
+void deepcopy_VkPushDescriptorSetInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* from,
+ VkPushDescriptorSetInfo* to);
+
+void deepcopy_VkPushDescriptorSetWithTemplateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* from,
+ VkPushDescriptorSetWithTemplateInfo* to);
+
+void deepcopy_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* from,
+ VkPhysicalDevicePipelineProtectedAccessFeatures* to);
+
+void deepcopy_VkPhysicalDevicePipelineRobustnessFeatures(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* from,
+ VkPhysicalDevicePipelineRobustnessFeatures* to);
+
+void deepcopy_VkPhysicalDevicePipelineRobustnessProperties(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* from,
+ VkPhysicalDevicePipelineRobustnessProperties* to);
+
+void deepcopy_VkPipelineRobustnessCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* from,
+ VkPipelineRobustnessCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceHostImageCopyFeatures(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostImageCopyFeatures* from,
+ VkPhysicalDeviceHostImageCopyFeatures* to);
+
+void deepcopy_VkPhysicalDeviceHostImageCopyProperties(
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostImageCopyProperties* from,
+ VkPhysicalDeviceHostImageCopyProperties* to);
+
+void deepcopy_VkMemoryToImageCopy(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryToImageCopy* from, VkMemoryToImageCopy* to);
+
+void deepcopy_VkImageToMemoryCopy(Allocator* alloc, VkStructureType rootType,
+ const VkImageToMemoryCopy* from, VkImageToMemoryCopy* to);
+
+void deepcopy_VkCopyMemoryToImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* from,
+ VkCopyMemoryToImageInfo* to);
+
+void deepcopy_VkCopyImageToMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* from,
+ VkCopyImageToMemoryInfo* to);
+
+void deepcopy_VkCopyImageToImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageToImageInfo* from,
+ VkCopyImageToImageInfo* to);
+
+void deepcopy_VkHostImageLayoutTransitionInfo(Allocator* alloc, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* from,
+ VkHostImageLayoutTransitionInfo* to);
+
+void deepcopy_VkSubresourceHostMemcpySize(Allocator* alloc, VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* from,
+ VkSubresourceHostMemcpySize* to);
+
+void deepcopy_VkHostImageCopyDevicePerformanceQuery(
+ Allocator* alloc, VkStructureType rootType, const VkHostImageCopyDevicePerformanceQuery* from,
+ VkHostImageCopyDevicePerformanceQuery* to);
+
+#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderingInfo, deepcopy_VkRenderingInfoKHR)
@@ -1160,27 +1372,6 @@
DEFINE_ALIAS_FUNCTION(deepcopy_VkCommandBufferInheritanceRenderingInfo,
deepcopy_VkCommandBufferInheritanceRenderingInfoKHR)
-void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* from,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* to);
-
-void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* to);
-
-void deepcopy_VkAttachmentSampleCountInfoAMD(Allocator* alloc, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* from,
- VkAttachmentSampleCountInfoAMD* to);
-
-DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentSampleCountInfoAMD,
- deepcopy_VkAttachmentSampleCountInfoNV)
-
-void deepcopy_VkMultiviewPerViewAttributesInfoNVX(Allocator* alloc, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* from,
- VkMultiviewPerViewAttributesInfoNVX* to);
-
#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFeatures2, deepcopy_VkPhysicalDeviceFeatures2KHR)
@@ -1498,13 +1689,6 @@
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSynchronization2Features,
deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR)
-void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* from,
- VkQueueFamilyCheckpointProperties2NV* to);
-
-void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
- const VkCheckpointData2NV* from, VkCheckpointData2NV* to);
-
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
@@ -1554,55 +1738,37 @@
#endif
#ifdef VK_KHR_maintenance5
-void deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR(
- Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance5FeaturesKHR* from,
- VkPhysicalDeviceMaintenance5FeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance5Features,
+ deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* from,
- VkPhysicalDeviceMaintenance5PropertiesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance5Properties,
+ deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void deepcopy_VkRenderingAreaInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* from,
- VkRenderingAreaInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderingAreaInfo, deepcopy_VkRenderingAreaInfoKHR)
-void deepcopy_VkImageSubresource2KHR(Allocator* alloc, VkStructureType rootType,
- const VkImageSubresource2KHR* from,
- VkImageSubresource2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceImageSubresourceInfo,
+ deepcopy_VkDeviceImageSubresourceInfoKHR)
-void deepcopy_VkDeviceImageSubresourceInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* from,
- VkDeviceImageSubresourceInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSubresource2, deepcopy_VkImageSubresource2KHR)
-void deepcopy_VkSubresourceLayout2KHR(Allocator* alloc, VkStructureType rootType,
- const VkSubresourceLayout2KHR* from,
- VkSubresourceLayout2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSubresourceLayout2, deepcopy_VkSubresourceLayout2KHR)
-void deepcopy_VkPipelineCreateFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* from,
- VkPipelineCreateFlags2CreateInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineCreateFlags2CreateInfo,
+ deepcopy_VkPipelineCreateFlags2CreateInfoKHR)
-void deepcopy_VkBufferUsageFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* from,
- VkBufferUsageFlags2CreateInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferUsageFlags2CreateInfo,
+ deepcopy_VkBufferUsageFlags2CreateInfoKHR)
#endif
#ifdef VK_KHR_line_rasterization
-void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* from,
- VkPhysicalDeviceLineRasterizationFeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceLineRasterizationFeatures,
+ deepcopy_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* from,
- VkPhysicalDeviceLineRasterizationPropertiesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceLineRasterizationProperties,
+ deepcopy_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void deepcopy_VkPipelineRasterizationLineStateCreateInfoKHR(
- Allocator* alloc, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* from,
- VkPipelineRasterizationLineStateCreateInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineRasterizationLineStateCreateInfo,
+ deepcopy_VkPipelineRasterizationLineStateCreateInfoKHR)
#endif
#ifdef VK_ANDROID_native_buffer
@@ -1714,13 +1880,13 @@
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkVertexInputBindingDivisorDescription,
deepcopy_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineVertexInputDivisorStateCreateInfo,
deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeatures,
deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
#endif
@@ -1747,6 +1913,11 @@
const VkRenderPassFragmentDensityMapCreateInfoEXT* from,
VkRenderPassFragmentDensityMapCreateInfoEXT* to);
+void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
+ VkRenderingFragmentDensityMapAttachmentInfoEXT* to);
+
#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures,
@@ -1787,18 +1958,18 @@
#endif
#ifdef VK_EXT_line_rasterization
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceLineRasterizationFeatures,
deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceLineRasterizationProperties,
deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineRasterizationLineStateCreateInfo,
deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT)
#endif
#ifdef VK_EXT_index_type_uint8
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceIndexTypeUint8Features,
deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
#endif
@@ -1810,52 +1981,33 @@
#endif
#ifdef VK_EXT_host_image_copy
-void deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* from,
- VkPhysicalDeviceHostImageCopyFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceHostImageCopyFeatures,
+ deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* from,
- VkPhysicalDeviceHostImageCopyPropertiesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceHostImageCopyProperties,
+ deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void deepcopy_VkMemoryToImageCopyEXT(Allocator* alloc, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* from,
- VkMemoryToImageCopyEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryToImageCopy, deepcopy_VkMemoryToImageCopyEXT)
-void deepcopy_VkImageToMemoryCopyEXT(Allocator* alloc, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* from,
- VkImageToMemoryCopyEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageToMemoryCopy, deepcopy_VkImageToMemoryCopyEXT)
-void deepcopy_VkCopyMemoryToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* from,
- VkCopyMemoryToImageInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyMemoryToImageInfo, deepcopy_VkCopyMemoryToImageInfoEXT)
-void deepcopy_VkCopyImageToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* from,
- VkCopyImageToMemoryInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyImageToMemoryInfo, deepcopy_VkCopyImageToMemoryInfoEXT)
-void deepcopy_VkCopyImageToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* from,
- VkCopyImageToImageInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyImageToImageInfo, deepcopy_VkCopyImageToImageInfoEXT)
-void deepcopy_VkHostImageLayoutTransitionInfoEXT(Allocator* alloc, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* from,
- VkHostImageLayoutTransitionInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkHostImageLayoutTransitionInfo,
+ deepcopy_VkHostImageLayoutTransitionInfoEXT)
-void deepcopy_VkSubresourceHostMemcpySizeEXT(Allocator* alloc, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* from,
- VkSubresourceHostMemcpySizeEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSubresourceHostMemcpySize, deepcopy_VkSubresourceHostMemcpySizeEXT)
-void deepcopy_VkHostImageCopyDevicePerformanceQueryEXT(
- Allocator* alloc, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* from,
- VkHostImageCopyDevicePerformanceQueryEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkHostImageCopyDevicePerformanceQuery,
+ deepcopy_VkHostImageCopyDevicePerformanceQueryEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSubresourceLayout2KHR, deepcopy_VkSubresourceLayout2EXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSubresourceLayout2, deepcopy_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSubresource2KHR, deepcopy_VkImageSubresource2EXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSubresource2, deepcopy_VkImageSubresource2EXT)
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/src/gfxstream/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index 0725c23..c03e62b 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -376,18 +376,108 @@
return sizeof(VkPhysicalDeviceMaintenance4Properties);
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR);
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ return sizeof(VkPhysicalDeviceVulkan14Features);
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceVulkan14Properties);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- return sizeof(VkAttachmentSampleCountInfoAMD);
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ return sizeof(VkDeviceQueueGlobalPriorityCreateInfo);
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- return sizeof(VkMultiviewPerViewAttributesInfoNVX);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeatures);
+ }
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ return sizeof(VkQueueFamilyGlobalPriorityProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ return sizeof(VkPhysicalDeviceShaderSubgroupRotateFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ return sizeof(VkPhysicalDeviceShaderFloatControls2Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ return sizeof(VkPhysicalDeviceShaderExpectAssumeFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ return sizeof(VkPhysicalDeviceLineRasterizationFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceLineRasterizationProperties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ return sizeof(VkPipelineRasterizationLineStateCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceVertexAttributeDivisorProperties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ return sizeof(VkPipelineVertexInputDivisorStateCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ return sizeof(VkPhysicalDeviceVertexAttributeDivisorFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ return sizeof(VkPhysicalDeviceIndexTypeUint8Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ return sizeof(VkPhysicalDeviceMaintenance5Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceMaintenance5Properties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ return sizeof(VkPipelineCreateFlags2CreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ return sizeof(VkBufferUsageFlags2CreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ return sizeof(VkPhysicalDevicePushDescriptorProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ return sizeof(VkPhysicalDeviceDynamicRenderingLocalReadFeatures);
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ return sizeof(VkRenderingAttachmentLocationInfo);
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ return sizeof(VkRenderingInputAttachmentIndexInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ return sizeof(VkPhysicalDeviceMaintenance6Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceMaintenance6Properties);
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ return sizeof(VkBindMemoryStatus);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ return sizeof(VkPhysicalDevicePipelineProtectedAccessFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ return sizeof(VkPhysicalDevicePipelineRobustnessFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ return sizeof(VkPhysicalDevicePipelineRobustnessProperties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ return sizeof(VkPipelineRobustnessCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ return sizeof(VkPhysicalDeviceHostImageCopyFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceHostImageCopyProperties);
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ return sizeof(VkSubresourceHostMemcpySize);
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ return sizeof(VkHostImageCopyDevicePerformanceQuery);
}
#endif
#ifdef VK_KHR_incremental_present
@@ -400,36 +490,6 @@
return sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- return sizeof(VkQueueFamilyCheckpointProperties2NV);
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- return sizeof(VkPhysicalDeviceMaintenance5FeaturesKHR);
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- return sizeof(VkPhysicalDeviceMaintenance5PropertiesKHR);
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- return sizeof(VkPipelineCreateFlags2CreateInfoKHR);
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- return sizeof(VkBufferUsageFlags2CreateInfoKHR);
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- return sizeof(VkPhysicalDeviceLineRasterizationFeaturesKHR);
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- return sizeof(VkPhysicalDeviceLineRasterizationPropertiesKHR);
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- return sizeof(VkPipelineRasterizationLineStateCreateInfoKHR);
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
return sizeof(VkNativeBufferANDROID);
@@ -533,6 +593,9 @@
}
}
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT);
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -550,20 +613,6 @@
return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- return sizeof(VkPhysicalDeviceHostImageCopyFeaturesEXT);
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- return sizeof(VkPhysicalDeviceHostImageCopyPropertiesEXT);
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- return sizeof(VkSubresourceHostMemcpySizeEXT);
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- return sizeof(VkHostImageCopyDevicePerformanceQueryEXT);
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
@@ -1012,18 +1061,108 @@
return sizeof(VkPhysicalDeviceMaintenance4Properties);
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR);
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ return sizeof(VkPhysicalDeviceVulkan14Features);
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceVulkan14Properties);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- return sizeof(VkAttachmentSampleCountInfoAMD);
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ return sizeof(VkDeviceQueueGlobalPriorityCreateInfo);
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- return sizeof(VkMultiviewPerViewAttributesInfoNVX);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeatures);
+ }
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ return sizeof(VkQueueFamilyGlobalPriorityProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ return sizeof(VkPhysicalDeviceShaderSubgroupRotateFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ return sizeof(VkPhysicalDeviceShaderFloatControls2Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ return sizeof(VkPhysicalDeviceShaderExpectAssumeFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ return sizeof(VkPhysicalDeviceLineRasterizationFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceLineRasterizationProperties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ return sizeof(VkPipelineRasterizationLineStateCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceVertexAttributeDivisorProperties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ return sizeof(VkPipelineVertexInputDivisorStateCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ return sizeof(VkPhysicalDeviceVertexAttributeDivisorFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ return sizeof(VkPhysicalDeviceIndexTypeUint8Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ return sizeof(VkPhysicalDeviceMaintenance5Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceMaintenance5Properties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ return sizeof(VkPipelineCreateFlags2CreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ return sizeof(VkBufferUsageFlags2CreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ return sizeof(VkPhysicalDevicePushDescriptorProperties);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ return sizeof(VkPhysicalDeviceDynamicRenderingLocalReadFeatures);
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ return sizeof(VkRenderingAttachmentLocationInfo);
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ return sizeof(VkRenderingInputAttachmentIndexInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ return sizeof(VkPhysicalDeviceMaintenance6Features);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceMaintenance6Properties);
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ return sizeof(VkBindMemoryStatus);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ return sizeof(VkPhysicalDevicePipelineProtectedAccessFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ return sizeof(VkPhysicalDevicePipelineRobustnessFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ return sizeof(VkPhysicalDevicePipelineRobustnessProperties);
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ return sizeof(VkPipelineRobustnessCreateInfo);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ return sizeof(VkPhysicalDeviceHostImageCopyFeatures);
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ return sizeof(VkPhysicalDeviceHostImageCopyProperties);
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ return sizeof(VkSubresourceHostMemcpySize);
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ return sizeof(VkHostImageCopyDevicePerformanceQuery);
}
#endif
#ifdef VK_KHR_incremental_present
@@ -1036,36 +1175,6 @@
return sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- return sizeof(VkQueueFamilyCheckpointProperties2NV);
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- return sizeof(VkPhysicalDeviceMaintenance5FeaturesKHR);
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- return sizeof(VkPhysicalDeviceMaintenance5PropertiesKHR);
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- return sizeof(VkPipelineCreateFlags2CreateInfoKHR);
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- return sizeof(VkBufferUsageFlags2CreateInfoKHR);
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- return sizeof(VkPhysicalDeviceLineRasterizationFeaturesKHR);
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- return sizeof(VkPhysicalDeviceLineRasterizationPropertiesKHR);
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- return sizeof(VkPipelineRasterizationLineStateCreateInfoKHR);
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
return sizeof(VkNativeBufferANDROID);
@@ -1169,6 +1278,9 @@
}
}
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT);
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -1186,20 +1298,6 @@
return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- return sizeof(VkPhysicalDeviceHostImageCopyFeaturesEXT);
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- return sizeof(VkPhysicalDeviceHostImageCopyPropertiesEXT);
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- return sizeof(VkSubresourceHostMemcpySizeEXT);
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- return sizeof(VkHostImageCopyDevicePerformanceQueryEXT);
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index 0cac289..ced0146 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -10806,77 +10806,945 @@
}
#endif
-#ifdef VK_KHR_dynamic_rendering
-void marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+void marshal_VkPhysicalDeviceVulkan14Features(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling) {
+ const VkPhysicalDeviceVulkan14Features* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
- 1);
- vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
- marshal_VkExtent2D(vkStream, rootType,
- (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
+ vkStream->write((VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupRotate, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupRotateClustered, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderFloatControls2, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderExpectAssume, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->dynamicRenderingLocalRead, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->maintenance6, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->pipelineRobustness, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->pushDescriptor, sizeof(VkBool32));
}
-void unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling) {
+void unmarshal_VkPhysicalDeviceVulkan14Features(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceVulkan14Features* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- uint64_t cgen_var_0;
- vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(
- &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
- unmarshal_VkExtent2D(vkStream, rootType,
- (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
+ vkStream->read((VkBool32*)&forUnmarshaling->globalPriorityQuery, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupRotate, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupRotateClustered, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderFloatControls2, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderExpectAssume, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rectangularLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->bresenhamLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->smoothLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledRectangularLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledBresenhamLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledSmoothLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateDivisor,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->indexTypeUint8, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->dynamicRenderingLocalRead, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->maintenance5, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->maintenance6, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->pipelineRobustness, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->hostImageCopy, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->pushDescriptor, sizeof(VkBool32));
}
-void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+void marshal_VkPhysicalDeviceVulkan14Properties(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling) {
+ const VkPhysicalDeviceVulkan14Properties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
- 1);
- vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
+ vkStream->write((uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->supportsNonZeroFirstInstance, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->dynamicRenderingLocalReadDepthStencilAttachments,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->dynamicRenderingLocalReadMultisampledAttachments,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->blockTexelViewCompatibleMultipleLayers,
+ sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxCombinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateClampCombinerInputs,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessStorageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write(
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessUniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write(
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessVertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write((VkPipelineRobustnessImageBehavior*)&forMarshaling->defaultRobustnessImages,
+ sizeof(VkPipelineRobustnessImageBehavior));
+ vkStream->write((uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pCopySrcLayouts) {
+ vkStream->write((VkImageLayout*)forMarshaling->pCopySrcLayouts,
+ forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
+ vkStream->putBe64(cgen_var_1);
+ if (forMarshaling->pCopyDstLayouts) {
+ vkStream->write((VkImageLayout*)forMarshaling->pCopyDstLayouts,
+ forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->write((uint8_t*)forMarshaling->optimalTilingLayoutUUID,
+ VK_UUID_SIZE * sizeof(uint8_t));
+ vkStream->write((VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
}
-void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+void unmarshal_VkPhysicalDeviceVulkan14Properties(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling) {
+ VkPhysicalDeviceVulkan14Properties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- uint64_t cgen_var_0;
- vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(
- &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
+ vkStream->read((uint32_t*)&forUnmarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->supportsNonZeroFirstInstance, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->dynamicRenderingLocalReadDepthStencilAttachments,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->dynamicRenderingLocalReadMultisampledAttachments,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->polygonModePointSize, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->nonStrictWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->blockTexelViewCompatibleMultipleLayers,
+ sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxCombinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateClampCombinerInputs,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->defaultRobustnessStorageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read(
+ (VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->defaultRobustnessUniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read(
+ (VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->defaultRobustnessVertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read((VkPipelineRobustnessImageBehavior*)&forUnmarshaling->defaultRobustnessImages,
+ sizeof(VkPipelineRobustnessImageBehavior));
+ vkStream->read((uint32_t*)&forUnmarshaling->copySrcLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ VkImageLayout* check_pCopySrcLayouts;
+ check_pCopySrcLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCopySrcLayouts) {
+ if (!(check_pCopySrcLayouts)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pCopySrcLayouts inconsistent between guest and host\n");
+ }
+ vkStream->read((VkImageLayout*)forUnmarshaling->pCopySrcLayouts,
+ forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->copyDstLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ VkImageLayout* check_pCopyDstLayouts;
+ check_pCopyDstLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCopyDstLayouts) {
+ if (!(check_pCopyDstLayouts)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pCopyDstLayouts inconsistent between guest and host\n");
+ }
+ vkStream->read((VkImageLayout*)forUnmarshaling->pCopyDstLayouts,
+ forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->read((uint8_t*)forUnmarshaling->optimalTilingLayoutUUID,
+ VK_UUID_SIZE * sizeof(uint8_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
}
-void marshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling) {
+void marshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkQueueGlobalPriority*)&forMarshaling->globalPriority,
+ sizeof(VkQueueGlobalPriority));
+}
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueGlobalPriorityCreateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkQueueGlobalPriority*)&forUnmarshaling->globalPriority,
+ sizeof(VkQueueGlobalPriority));
+}
+
+void marshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceGlobalPriorityQueryFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->globalPriorityQuery, sizeof(VkBool32));
+}
+
+void marshal_VkQueueFamilyGlobalPriorityProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityProperties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
+ vkStream->write((VkQueueGlobalPriority*)forMarshaling->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE * sizeof(VkQueueGlobalPriority));
+}
+
+void unmarshal_VkQueueFamilyGlobalPriorityProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyGlobalPriorityProperties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->priorityCount, sizeof(uint32_t));
+ vkStream->read((VkQueueGlobalPriority*)forUnmarshaling->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE * sizeof(VkQueueGlobalPriority));
+}
+
+void marshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupRotate, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSubgroupRotateClustered, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderSubgroupRotateFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupRotate, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSubgroupRotateClustered, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderFloatControls2Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->shaderFloatControls2, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderFloatControls2Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderFloatControls2Features* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderFloatControls2, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->shaderExpectAssume, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderExpectAssumeFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderExpectAssume, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceLineRasterizationFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceLineRasterizationFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLineRasterizationFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->rectangularLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->bresenhamLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->smoothLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledRectangularLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledBresenhamLines, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledSmoothLines, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceLineRasterizationProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceLineRasterizationProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLineRasterizationProperties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineRasterizationLineStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkLineRasterizationMode*)&forMarshaling->lineRasterizationMode,
+ sizeof(VkLineRasterizationMode));
+ vkStream->write((VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
+ vkStream->write((uint16_t*)&forMarshaling->lineStipplePattern, sizeof(uint16_t));
+}
+
+void unmarshal_VkPipelineRasterizationLineStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationLineStateCreateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkLineRasterizationMode*)&forUnmarshaling->lineRasterizationMode,
+ sizeof(VkLineRasterizationMode));
+ vkStream->read((VkBool32*)&forUnmarshaling->stippledLineEnable, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->lineStippleFactor, sizeof(uint32_t));
+ vkStream->read((uint16_t*)&forUnmarshaling->lineStipplePattern, sizeof(uint16_t));
+}
+
+void marshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->supportsNonZeroFirstInstance, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexAttributeDivisorProperties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->supportsNonZeroFirstInstance, sizeof(VkBool32));
+}
+
+void marshal_VkVertexInputBindingDivisorDescription(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescription* forMarshaling) {
+ (void)rootType;
+ vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
+}
+
+void unmarshal_VkVertexInputBindingDivisorDescription(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVertexInputBindingDivisorDescription* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
+}
+
+void marshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i) {
+ marshal_VkVertexInputBindingDivisorDescription(
+ vkStream, rootType,
+ (const VkVertexInputBindingDivisorDescription*)(forMarshaling
+ ->pVertexBindingDivisors +
+ i));
+ }
+ }
+}
+
+void unmarshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineVertexInputDivisorStateCreateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i) {
+ unmarshal_VkVertexInputBindingDivisorDescription(
+ vkStream, rootType,
+ (VkVertexInputBindingDivisorDescription*)(forUnmarshaling->pVertexBindingDivisors +
+ i));
+ }
+ }
+}
+
+void marshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexAttributeDivisorFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateDivisor,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceIndexTypeUint8Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8Features* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceIndexTypeUint8Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceIndexTypeUint8Features* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->indexTypeUint8, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryMapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryMapInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkMemoryMapFlags*)&forMarshaling->flags, sizeof(VkMemoryMapFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkMemoryMapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryMapInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkMemoryMapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryMapFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkMemoryUnmapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryUnmapInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkMemoryUnmapFlags*)&forMarshaling->flags, sizeof(VkMemoryUnmapFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+}
+
+void unmarshal_VkMemoryUnmapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryUnmapInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkMemoryUnmapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryUnmapFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+}
+
+void marshal_VkPhysicalDeviceMaintenance5Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance5Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance5Features* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->maintenance5, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMaintenance5Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Properties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram,
+ sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance5Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance5Properties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->polygonModePointSize, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->nonStrictWideLinesUseParallelogram,
+ sizeof(VkBool32));
+}
+
+void marshal_VkRenderingAreaInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAreaInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pColorAttachmentFormats) {
+ vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
+ forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ }
+ vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
+ vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+}
+
+void unmarshal_VkRenderingAreaInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingAreaInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ const VkFormat* check_pColorAttachmentFormats;
+ check_pColorAttachmentFormats = (const VkFormat*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pColorAttachmentFormats) {
+ if (!(check_pColorAttachmentFormats)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pColorAttachmentFormats inconsistent between guest "
+ "and host\n");
+ }
+ vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
+ forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ }
+ vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
+ vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+}
+
+void marshal_VkImageSubresource2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource2* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkImageSubresource(vkStream, rootType,
+ (VkImageSubresource*)(&forMarshaling->imageSubresource));
+}
+
+void unmarshal_VkImageSubresource2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresource2* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ unmarshal_VkImageSubresource(vkStream, rootType,
+ (VkImageSubresource*)(&forUnmarshaling->imageSubresource));
+}
+
+void marshal_VkDeviceImageSubresourceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkImageCreateInfo(vkStream, rootType,
+ (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
+ marshal_VkImageSubresource2(vkStream, rootType,
+ (const VkImageSubresource2*)(forMarshaling->pSubresource));
+}
+
+void unmarshal_VkDeviceImageSubresourceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceImageSubresourceInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ unmarshal_VkImageCreateInfo(vkStream, rootType,
+ (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
+ unmarshal_VkImageSubresource2(vkStream, rootType,
+ (VkImageSubresource2*)(forUnmarshaling->pSubresource));
+}
+
+void marshal_VkSubresourceLayout2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout2* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ marshal_VkSubresourceLayout(vkStream, rootType,
+ (VkSubresourceLayout*)(&forMarshaling->subresourceLayout));
+}
+
+void unmarshal_VkSubresourceLayout2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubresourceLayout2* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ unmarshal_VkSubresourceLayout(vkStream, rootType,
+ (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout));
+}
+
+void marshal_VkPipelineCreateFlags2CreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkPipelineCreateFlags2*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags2));
+}
+
+void unmarshal_VkPipelineCreateFlags2CreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineCreateFlags2CreateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkPipelineCreateFlags2*)&forUnmarshaling->flags,
+ sizeof(VkPipelineCreateFlags2));
+}
+
+void marshal_VkBufferUsageFlags2CreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBufferUsageFlags2*)&forMarshaling->usage, sizeof(VkBufferUsageFlags2));
+}
+
+void unmarshal_VkBufferUsageFlags2CreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferUsageFlags2CreateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBufferUsageFlags2*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags2));
+}
+
+void marshal_VkPhysicalDevicePushDescriptorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDevicePushDescriptorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePushDescriptorProperties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPushDescriptors, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->dynamicRenderingLocalRead, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->dynamicRenderingLocalRead, sizeof(VkBool32));
+}
+
+void marshal_VkRenderingAttachmentLocationInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -10885,18 +11753,17 @@
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentSamples;
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentLocations;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pColorAttachmentSamples) {
- vkStream->write((const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples,
- forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
+ if (forMarshaling->pColorAttachmentLocations) {
+ vkStream->write((const uint32_t*)forMarshaling->pColorAttachmentLocations,
+ forMarshaling->colorAttachmentCount * sizeof(const uint32_t));
}
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples,
- sizeof(VkSampleCountFlagBits));
}
-void unmarshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkAttachmentSampleCountInfoAMD* forUnmarshaling) {
+void unmarshal_VkRenderingAttachmentLocationInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingAttachmentLocationInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -10905,45 +11772,893 @@
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
// WARNING PTR CHECK
- const VkSampleCountFlagBits* check_pColorAttachmentSamples;
- check_pColorAttachmentSamples = (const VkSampleCountFlagBits*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pColorAttachmentSamples) {
- if (!(check_pColorAttachmentSamples)) {
+ const uint32_t* check_pColorAttachmentLocations;
+ check_pColorAttachmentLocations = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pColorAttachmentLocations) {
+ if (!(check_pColorAttachmentLocations)) {
fprintf(stderr,
- "fatal: forUnmarshaling->pColorAttachmentSamples inconsistent between guest "
+ "fatal: forUnmarshaling->pColorAttachmentLocations inconsistent between guest "
"and host\n");
}
- vkStream->read((VkSampleCountFlagBits*)forUnmarshaling->pColorAttachmentSamples,
- forUnmarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
+ vkStream->read((uint32_t*)forUnmarshaling->pColorAttachmentLocations,
+ forUnmarshaling->colorAttachmentCount * sizeof(const uint32_t));
}
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->depthStencilAttachmentSamples,
- sizeof(VkSampleCountFlagBits));
}
-void marshal_VkMultiviewPerViewAttributesInfoNVX(
+void marshal_VkRenderingInputAttachmentIndexInfo(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling) {
+ const VkRenderingInputAttachmentIndexInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->perViewAttributes, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->perViewAttributesPositionXOnly, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentInputIndices;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pColorAttachmentInputIndices) {
+ vkStream->write((const uint32_t*)forMarshaling->pColorAttachmentInputIndices,
+ forMarshaling->colorAttachmentCount * sizeof(const uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthInputAttachmentIndex;
+ vkStream->putBe64(cgen_var_1);
+ if (forMarshaling->pDepthInputAttachmentIndex) {
+ vkStream->write((const uint32_t*)forMarshaling->pDepthInputAttachmentIndex,
+ sizeof(const uint32_t));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pStencilInputAttachmentIndex;
+ vkStream->putBe64(cgen_var_2);
+ if (forMarshaling->pStencilInputAttachmentIndex) {
+ vkStream->write((const uint32_t*)forMarshaling->pStencilInputAttachmentIndex,
+ sizeof(const uint32_t));
+ }
}
-void unmarshal_VkMultiviewPerViewAttributesInfoNVX(
+void unmarshal_VkRenderingInputAttachmentIndexInfo(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkMultiviewPerViewAttributesInfoNVX* forUnmarshaling) {
+ VkRenderingInputAttachmentIndexInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->perViewAttributes, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->perViewAttributesPositionXOnly, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ const uint32_t* check_pColorAttachmentInputIndices;
+ check_pColorAttachmentInputIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pColorAttachmentInputIndices) {
+ if (!(check_pColorAttachmentInputIndices)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pColorAttachmentInputIndices inconsistent between "
+ "guest and host\n");
+ }
+ vkStream->read((uint32_t*)forUnmarshaling->pColorAttachmentInputIndices,
+ forUnmarshaling->colorAttachmentCount * sizeof(const uint32_t));
+ }
+ // WARNING PTR CHECK
+ const uint32_t* check_pDepthInputAttachmentIndex;
+ check_pDepthInputAttachmentIndex = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDepthInputAttachmentIndex) {
+ if (!(check_pDepthInputAttachmentIndex)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDepthInputAttachmentIndex inconsistent between guest "
+ "and host\n");
+ }
+ vkStream->read((uint32_t*)forUnmarshaling->pDepthInputAttachmentIndex,
+ sizeof(const uint32_t));
+ }
+ // WARNING PTR CHECK
+ const uint32_t* check_pStencilInputAttachmentIndex;
+ check_pStencilInputAttachmentIndex = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pStencilInputAttachmentIndex) {
+ if (!(check_pStencilInputAttachmentIndex)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pStencilInputAttachmentIndex inconsistent between "
+ "guest and host\n");
+ }
+ vkStream->read((uint32_t*)forUnmarshaling->pStencilInputAttachmentIndex,
+ sizeof(const uint32_t));
+ }
+}
+
+void marshal_VkPhysicalDeviceMaintenance6Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->maintenance6, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance6Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance6Features* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->maintenance6, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMaintenance6Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Properties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->blockTexelViewCompatibleMultipleLayers,
+ sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxCombinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateClampCombinerInputs,
+ sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance6Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance6Properties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->blockTexelViewCompatibleMultipleLayers,
+ sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxCombinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateClampCombinerInputs,
+ sizeof(VkBool32));
+}
+
+void marshal_VkBindMemoryStatus(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindMemoryStatus* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkResult*)forMarshaling->pResult, sizeof(VkResult));
+}
+
+void unmarshal_VkBindMemoryStatus(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindMemoryStatus* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkResult*)forUnmarshaling->pResult, sizeof(VkResult));
+}
+
+void marshal_VkBindDescriptorSetsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->firstSet, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
+ if (forMarshaling->descriptorSetCount) {
+ uint64_t* cgen_var_1;
+ vkStream->alloc((void**)&cgen_var_1, forMarshaling->descriptorSetCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(
+ forMarshaling->pDescriptorSets, cgen_var_1, forMarshaling->descriptorSetCount);
+ vkStream->write((uint64_t*)cgen_var_1, forMarshaling->descriptorSetCount * 8);
+ }
+ vkStream->write((uint32_t*)&forMarshaling->dynamicOffsetCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicOffsets;
+ vkStream->putBe64(cgen_var_2);
+ if (forMarshaling->pDynamicOffsets) {
+ vkStream->write((const uint32_t*)forMarshaling->pDynamicOffsets,
+ forMarshaling->dynamicOffsetCount * sizeof(const uint32_t));
+ }
+}
+
+void unmarshal_VkBindDescriptorSetsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindDescriptorSetsInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->firstSet, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
+ if (forUnmarshaling->descriptorSetCount) {
+ uint64_t* cgen_var_1;
+ vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->descriptorSetCount * 8);
+ vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->descriptorSetCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
+ cgen_var_1, (VkDescriptorSet*)forUnmarshaling->pDescriptorSets,
+ forUnmarshaling->descriptorSetCount);
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->dynamicOffsetCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ const uint32_t* check_pDynamicOffsets;
+ check_pDynamicOffsets = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDynamicOffsets) {
+ if (!(check_pDynamicOffsets)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pDynamicOffsets inconsistent between guest and host\n");
+ }
+ vkStream->read((uint32_t*)forUnmarshaling->pDynamicOffsets,
+ forUnmarshaling->dynamicOffsetCount * sizeof(const uint32_t));
+ }
+}
+
+void marshal_VkPushConstantsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantsInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
+ vkStream->write((const void*)forMarshaling->pValues,
+ forMarshaling->size * sizeof(const uint8_t));
+}
+
+void unmarshal_VkPushConstantsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushConstantsInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
+ vkStream->read((void*)forUnmarshaling->pValues, forUnmarshaling->size * sizeof(const uint8_t));
+}
+
+void marshal_VkPushDescriptorSetInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->descriptorWriteCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorWriteCount; ++i) {
+ marshal_VkWriteDescriptorSet(
+ vkStream, rootType,
+ (const VkWriteDescriptorSet*)(forMarshaling->pDescriptorWrites + i));
+ }
+ }
+}
+
+void unmarshal_VkPushDescriptorSetInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushDescriptorSetInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->descriptorWriteCount, sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorWriteCount; ++i) {
+ unmarshal_VkWriteDescriptorSet(
+ vkStream, rootType,
+ (VkWriteDescriptorSet*)(forUnmarshaling->pDescriptorWrites + i));
+ }
+ }
+}
+
+void marshal_VkPushDescriptorSetWithTemplateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(
+ &forMarshaling->descriptorUpdateTemplate, &cgen_var_0, 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ uint64_t cgen_var_1;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_1,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+ vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
+ vkStream->write((const void*)forMarshaling->pData, sizeof(const uint8_t));
+}
+
+void unmarshal_VkPushDescriptorSetWithTemplateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushDescriptorSetWithTemplateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(
+ &cgen_var_0, (VkDescriptorUpdateTemplate*)&forUnmarshaling->descriptorUpdateTemplate, 1);
+ uint64_t cgen_var_1;
+ vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_1, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
+ vkStream->read((void*)forUnmarshaling->pData, sizeof(const uint8_t));
+}
+
+void marshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineProtectedAccessFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->pipelineRobustness, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineRobustnessFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->pipelineRobustness, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDevicePipelineRobustnessProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write(
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessStorageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write(
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessUniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write(
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessVertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write((VkPipelineRobustnessImageBehavior*)&forMarshaling->defaultRobustnessImages,
+ sizeof(VkPipelineRobustnessImageBehavior));
+}
+
+void unmarshal_VkPhysicalDevicePipelineRobustnessProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineRobustnessProperties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read(
+ (VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->defaultRobustnessStorageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read(
+ (VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->defaultRobustnessUniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read(
+ (VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->defaultRobustnessVertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read((VkPipelineRobustnessImageBehavior*)&forUnmarshaling->defaultRobustnessImages,
+ sizeof(VkPipelineRobustnessImageBehavior));
+}
+
+void marshal_VkPipelineRobustnessCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkPipelineRobustnessBufferBehavior*)&forMarshaling->storageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write((VkPipelineRobustnessBufferBehavior*)&forMarshaling->uniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write((VkPipelineRobustnessBufferBehavior*)&forMarshaling->vertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->write((VkPipelineRobustnessImageBehavior*)&forMarshaling->images,
+ sizeof(VkPipelineRobustnessImageBehavior));
+}
+
+void unmarshal_VkPipelineRobustnessCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRobustnessCreateInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->storageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read((VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->uniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read((VkPipelineRobustnessBufferBehavior*)&forUnmarshaling->vertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ vkStream->read((VkPipelineRobustnessImageBehavior*)&forUnmarshaling->images,
+ sizeof(VkPipelineRobustnessImageBehavior));
+}
+
+void marshal_VkPhysicalDeviceHostImageCopyFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyFeatures* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceHostImageCopyFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceHostImageCopyFeatures* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->hostImageCopy, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceHostImageCopyProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyProperties* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pCopySrcLayouts) {
+ vkStream->write((VkImageLayout*)forMarshaling->pCopySrcLayouts,
+ forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->write((uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
+ vkStream->putBe64(cgen_var_1);
+ if (forMarshaling->pCopyDstLayouts) {
+ vkStream->write((VkImageLayout*)forMarshaling->pCopyDstLayouts,
+ forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->write((uint8_t*)forMarshaling->optimalTilingLayoutUUID,
+ VK_UUID_SIZE * sizeof(uint8_t));
+ vkStream->write((VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceHostImageCopyProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceHostImageCopyProperties* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((uint32_t*)&forUnmarshaling->copySrcLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ VkImageLayout* check_pCopySrcLayouts;
+ check_pCopySrcLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCopySrcLayouts) {
+ if (!(check_pCopySrcLayouts)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pCopySrcLayouts inconsistent between guest and host\n");
+ }
+ vkStream->read((VkImageLayout*)forUnmarshaling->pCopySrcLayouts,
+ forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->copyDstLayoutCount, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ VkImageLayout* check_pCopyDstLayouts;
+ check_pCopyDstLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pCopyDstLayouts) {
+ if (!(check_pCopyDstLayouts)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pCopyDstLayouts inconsistent between guest and host\n");
+ }
+ vkStream->read((VkImageLayout*)forUnmarshaling->pCopyDstLayouts,
+ forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+ }
+ vkStream->read((uint8_t*)forUnmarshaling->optimalTilingLayoutUUID,
+ VK_UUID_SIZE * sizeof(uint8_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryToImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryToImageCopy* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((const void*)forMarshaling->pHostPointer, sizeof(const uint8_t));
+ vkStream->write((uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+ marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
+ marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkMemoryToImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryToImageCopy* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(const uint8_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryRowLength, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryImageHeight, sizeof(uint32_t));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+ unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+ unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkImageToMemoryCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageToMemoryCopy* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
+ vkStream->write((uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+ marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
+ marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkImageToMemoryCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageToMemoryCopy* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryRowLength, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryImageHeight, sizeof(uint32_t));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+ unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+ unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkCopyMemoryToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkHostImageCopyFlags*)&forMarshaling->flags, sizeof(VkHostImageCopyFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_0, 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+ vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkMemoryToImageCopy(vkStream, rootType,
+ (const VkMemoryToImageCopy*)(forMarshaling->pRegions + i));
+ }
+ }
+}
+
+void unmarshal_VkCopyMemoryToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyMemoryToImageInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkHostImageCopyFlags*)&forUnmarshaling->flags, sizeof(VkHostImageCopyFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->dstImage, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+ vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkMemoryToImageCopy(vkStream, rootType,
+ (VkMemoryToImageCopy*)(forUnmarshaling->pRegions + i));
+ }
+ }
+}
+
+void marshal_VkCopyImageToMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkHostImageCopyFlags*)&forMarshaling->flags, sizeof(VkHostImageCopyFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+ vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkImageToMemoryCopy(vkStream, rootType,
+ (const VkImageToMemoryCopy*)(forMarshaling->pRegions + i));
+ }
+ }
+}
+
+void unmarshal_VkCopyImageToMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageToMemoryInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkHostImageCopyFlags*)&forUnmarshaling->flags, sizeof(VkHostImageCopyFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->srcImage, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+ vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkImageToMemoryCopy(vkStream, rootType,
+ (VkImageToMemoryCopy*)(forUnmarshaling->pRegions + i));
+ }
+ }
+}
+
+void marshal_VkCopyImageToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToImageInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkHostImageCopyFlags*)&forMarshaling->flags, sizeof(VkHostImageCopyFlags));
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_1;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
+ vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+ vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkImageCopy2(vkStream, rootType,
+ (const VkImageCopy2*)(forMarshaling->pRegions + i));
+ }
+ }
+}
+
+void unmarshal_VkCopyImageToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageToImageInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkHostImageCopyFlags*)&forUnmarshaling->flags, sizeof(VkHostImageCopyFlags));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->srcImage, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+ uint64_t cgen_var_1;
+ vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+ (VkImage*)&forUnmarshaling->dstImage, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+ vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkImageCopy2(vkStream, rootType,
+ (VkImageCopy2*)(forUnmarshaling->pRegions + i));
+ }
+ }
+}
+
+void marshal_VkHostImageLayoutTransitionInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
+ vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
+ marshal_VkImageSubresourceRange(vkStream, rootType,
+ (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+}
+
+void unmarshal_VkHostImageLayoutTransitionInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkHostImageLayoutTransitionInfo* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
+ vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
+ unmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+}
+
+void marshal_VkSubresourceHostMemcpySize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkSubresourceHostMemcpySize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubresourceHostMemcpySize* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkHostImageCopyDevicePerformanceQuery(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageCopyDevicePerformanceQuery* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->optimalDeviceAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->identicalMemoryLayout, sizeof(VkBool32));
+}
+
+void unmarshal_VkHostImageCopyDevicePerformanceQuery(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkHostImageCopyDevicePerformanceQuery* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ vkStream->read((VkBool32*)&forUnmarshaling->optimalDeviceAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryLayout, sizeof(VkBool32));
}
#endif
@@ -11396,408 +13111,6 @@
}
#endif
-#ifdef VK_KHR_synchronization2
-void marshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2*)&forMarshaling->checkpointExecutionStageMask,
- sizeof(VkPipelineStageFlags2));
-}
-
-void unmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkQueueFamilyCheckpointProperties2NV* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->checkpointExecutionStageMask,
- sizeof(VkPipelineStageFlags2));
-}
-
-void marshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2*)&forMarshaling->stage, sizeof(VkPipelineStageFlags2));
- // WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
- vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pCheckpointMarker) {
- vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
- }
-}
-
-void unmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCheckpointData2NV* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlags2));
- // WARNING PTR CHECK
- void* check_pCheckpointMarker;
- check_pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCheckpointMarker) {
- if (!(check_pCheckpointMarker)) {
- fprintf(
- stderr,
- "fatal: forUnmarshaling->pCheckpointMarker inconsistent between guest and host\n");
- }
- vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
- }
-}
-
-#endif
-#ifdef VK_KHR_maintenance5
-void marshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5FeaturesKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceMaintenance5FeaturesKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->maintenance5, sizeof(VkBool32));
-}
-
-void marshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
- sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
- sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
- sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram,
- sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceMaintenance5PropertiesKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
- sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
- sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->polygonModePointSize, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
- sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->nonStrictWideLinesUseParallelogram,
- sizeof(VkBool32));
-}
-
-void marshal_VkRenderingAreaInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- // WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
- vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pColorAttachmentFormats) {
- vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
- forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
- }
- vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
- vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
-}
-
-void unmarshal_VkRenderingAreaInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkRenderingAreaInfoKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
- // WARNING PTR CHECK
- const VkFormat* check_pColorAttachmentFormats;
- check_pColorAttachmentFormats = (const VkFormat*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pColorAttachmentFormats) {
- if (!(check_pColorAttachmentFormats)) {
- fprintf(stderr,
- "fatal: forUnmarshaling->pColorAttachmentFormats inconsistent between guest "
- "and host\n");
- }
- vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
- forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
- }
- vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
- vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
-}
-
-void marshal_VkImageSubresource2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageSubresource2KHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageSubresource(vkStream, rootType,
- (VkImageSubresource*)(&forMarshaling->imageSubresource));
-}
-
-void unmarshal_VkImageSubresource2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkImageSubresource2KHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresource(vkStream, rootType,
- (VkImageSubresource*)(&forUnmarshaling->imageSubresource));
-}
-
-void marshal_VkDeviceImageSubresourceInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageCreateInfo(vkStream, rootType,
- (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
- marshal_VkImageSubresource2KHR(vkStream, rootType,
- (const VkImageSubresource2KHR*)(forMarshaling->pSubresource));
-}
-
-void unmarshal_VkDeviceImageSubresourceInfoKHR(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceImageSubresourceInfoKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageCreateInfo(vkStream, rootType,
- (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
- unmarshal_VkImageSubresource2KHR(vkStream, rootType,
- (VkImageSubresource2KHR*)(forUnmarshaling->pSubresource));
-}
-
-void marshal_VkSubresourceLayout2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceLayout2KHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkSubresourceLayout(vkStream, rootType,
- (VkSubresourceLayout*)(&forMarshaling->subresourceLayout));
-}
-
-void unmarshal_VkSubresourceLayout2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkSubresourceLayout2KHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSubresourceLayout(vkStream, rootType,
- (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout));
-}
-
-void marshal_VkPipelineCreateFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineCreateFlags2KHR*)&forMarshaling->flags,
- sizeof(VkPipelineCreateFlags2KHR));
-}
-
-void unmarshal_VkPipelineCreateFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPipelineCreateFlags2CreateInfoKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineCreateFlags2KHR*)&forUnmarshaling->flags,
- sizeof(VkPipelineCreateFlags2KHR));
-}
-
-void marshal_VkBufferUsageFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBufferUsageFlags2KHR*)&forMarshaling->usage, sizeof(VkBufferUsageFlags2KHR));
-}
-
-void unmarshal_VkBufferUsageFlags2CreateInfoKHR(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferUsageFlags2CreateInfoKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBufferUsageFlags2KHR*)&forUnmarshaling->usage,
- sizeof(VkBufferUsageFlags2KHR));
-}
-
-#endif
-#ifdef VK_KHR_line_rasterization
-void marshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceLineRasterizationFeaturesKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->rectangularLines, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->bresenhamLines, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->smoothLines, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->stippledRectangularLines, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->stippledBresenhamLines, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->stippledSmoothLines, sizeof(VkBool32));
-}
-
-void marshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
-}
-
-void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceLineRasterizationPropertiesKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
-}
-
-void marshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkLineRasterizationModeKHR*)&forMarshaling->lineRasterizationMode,
- sizeof(VkLineRasterizationModeKHR));
- vkStream->write((VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
- vkStream->write((uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
- vkStream->write((uint16_t*)&forMarshaling->lineStipplePattern, sizeof(uint16_t));
-}
-
-void unmarshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPipelineRasterizationLineStateCreateInfoKHR* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkLineRasterizationModeKHR*)&forUnmarshaling->lineRasterizationMode,
- sizeof(VkLineRasterizationModeKHR));
- vkStream->read((VkBool32*)&forUnmarshaling->stippledLineEnable, sizeof(VkBool32));
- vkStream->read((uint32_t*)&forUnmarshaling->lineStippleFactor, sizeof(uint32_t));
- vkStream->read((uint16_t*)&forUnmarshaling->lineStipplePattern, sizeof(uint16_t));
-}
-
-#endif
#ifdef VK_ANDROID_native_buffer
void marshal_VkNativeBufferUsage2ANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkNativeBufferUsage2ANDROID* forMarshaling) {
@@ -12487,6 +13800,38 @@
(VkAttachmentReference*)(&forUnmarshaling->fragmentDensityMapAttachment));
}
+void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ uint64_t cgen_var_0;
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
+}
+
+void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ uint64_t cgen_var_0;
+ vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
+}
+
#endif
#ifdef VK_EXT_provoking_vertex
void marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
@@ -12599,405 +13944,6 @@
}
#endif
-#ifdef VK_EXT_host_image_copy
-void marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceHostImageCopyFeaturesEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->hostImageCopy, sizeof(VkBool32));
-}
-
-void marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
- // WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
- vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pCopySrcLayouts) {
- vkStream->write((VkImageLayout*)forMarshaling->pCopySrcLayouts,
- forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
- }
- vkStream->write((uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
- // WARNING PTR CHECK
- uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
- vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pCopyDstLayouts) {
- vkStream->write((VkImageLayout*)forMarshaling->pCopyDstLayouts,
- forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
- }
- vkStream->write((uint8_t*)forMarshaling->optimalTilingLayoutUUID,
- VK_UUID_SIZE * sizeof(uint8_t));
- vkStream->write((VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceHostImageCopyPropertiesEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->copySrcLayoutCount, sizeof(uint32_t));
- // WARNING PTR CHECK
- VkImageLayout* check_pCopySrcLayouts;
- check_pCopySrcLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCopySrcLayouts) {
- if (!(check_pCopySrcLayouts)) {
- fprintf(
- stderr,
- "fatal: forUnmarshaling->pCopySrcLayouts inconsistent between guest and host\n");
- }
- vkStream->read((VkImageLayout*)forUnmarshaling->pCopySrcLayouts,
- forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
- }
- vkStream->read((uint32_t*)&forUnmarshaling->copyDstLayoutCount, sizeof(uint32_t));
- // WARNING PTR CHECK
- VkImageLayout* check_pCopyDstLayouts;
- check_pCopyDstLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCopyDstLayouts) {
- if (!(check_pCopyDstLayouts)) {
- fprintf(
- stderr,
- "fatal: forUnmarshaling->pCopyDstLayouts inconsistent between guest and host\n");
- }
- vkStream->read((VkImageLayout*)forUnmarshaling->pCopyDstLayouts,
- forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
- }
- vkStream->read((uint8_t*)forUnmarshaling->optimalTilingLayoutUUID,
- VK_UUID_SIZE * sizeof(uint8_t));
- vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
-}
-
-void marshal_VkMemoryToImageCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const void*)forMarshaling->pHostPointer, sizeof(const uint8_t));
- vkStream->write((uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
- marshal_VkImageSubresourceLayers(vkStream, rootType,
- (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
- marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
- marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
-}
-
-void unmarshal_VkMemoryToImageCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkMemoryToImageCopyEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(const uint8_t));
- vkStream->read((uint32_t*)&forUnmarshaling->memoryRowLength, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->memoryImageHeight, sizeof(uint32_t));
- unmarshal_VkImageSubresourceLayers(
- vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
- unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
- unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
-}
-
-void marshal_VkImageToMemoryCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
- vkStream->write((uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
- marshal_VkImageSubresourceLayers(vkStream, rootType,
- (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
- marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
- marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
-}
-
-void unmarshal_VkImageToMemoryCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkImageToMemoryCopyEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
- vkStream->read((uint32_t*)&forUnmarshaling->memoryRowLength, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->memoryImageHeight, sizeof(uint32_t));
- unmarshal_VkImageSubresourceLayers(
- vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
- unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
- unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
-}
-
-void marshal_VkCopyMemoryToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkHostImageCopyFlagsEXT*)&forMarshaling->flags,
- sizeof(VkHostImageCopyFlagsEXT));
- uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_0, 1);
- vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
- vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling) {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
- marshal_VkMemoryToImageCopyEXT(
- vkStream, rootType, (const VkMemoryToImageCopyEXT*)(forMarshaling->pRegions + i));
- }
- }
-}
-
-void unmarshal_VkCopyMemoryToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCopyMemoryToImageInfoEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags,
- sizeof(VkHostImageCopyFlagsEXT));
- uint64_t cgen_var_0;
- vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
- (VkImage*)&forUnmarshaling->dstImage, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
- vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling) {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
- unmarshal_VkMemoryToImageCopyEXT(
- vkStream, rootType, (VkMemoryToImageCopyEXT*)(forUnmarshaling->pRegions + i));
- }
- }
-}
-
-void marshal_VkCopyImageToMemoryInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkHostImageCopyFlagsEXT*)&forMarshaling->flags,
- sizeof(VkHostImageCopyFlagsEXT));
- uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
- vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
- vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling) {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
- marshal_VkImageToMemoryCopyEXT(
- vkStream, rootType, (const VkImageToMemoryCopyEXT*)(forMarshaling->pRegions + i));
- }
- }
-}
-
-void unmarshal_VkCopyImageToMemoryInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCopyImageToMemoryInfoEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags,
- sizeof(VkHostImageCopyFlagsEXT));
- uint64_t cgen_var_0;
- vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
- (VkImage*)&forUnmarshaling->srcImage, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
- vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling) {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
- unmarshal_VkImageToMemoryCopyEXT(
- vkStream, rootType, (VkImageToMemoryCopyEXT*)(forUnmarshaling->pRegions + i));
- }
- }
-}
-
-void marshal_VkCopyImageToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkHostImageCopyFlagsEXT*)&forMarshaling->flags,
- sizeof(VkHostImageCopyFlagsEXT));
- uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
- vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
- vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
- vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling) {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
- marshal_VkImageCopy2(vkStream, rootType,
- (const VkImageCopy2*)(forMarshaling->pRegions + i));
- }
- }
-}
-
-void unmarshal_VkCopyImageToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCopyImageToImageInfoEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags,
- sizeof(VkHostImageCopyFlagsEXT));
- uint64_t cgen_var_0;
- vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
- (VkImage*)&forUnmarshaling->srcImage, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_1;
- vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
- (VkImage*)&forUnmarshaling->dstImage, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
- vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling) {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
- unmarshal_VkImageCopy2(vkStream, rootType,
- (VkImageCopy2*)(forUnmarshaling->pRegions + i));
- }
- }
-}
-
-void marshal_VkHostImageLayoutTransitionInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
- vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
- vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
- marshal_VkImageSubresourceRange(vkStream, rootType,
- (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
-}
-
-void unmarshal_VkHostImageLayoutTransitionInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkHostImageLayoutTransitionInfoEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- uint64_t cgen_var_0;
- vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
- (VkImage*)&forUnmarshaling->image, 1);
- vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
- vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
- unmarshal_VkImageSubresourceRange(
- vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
-}
-
-void marshal_VkSubresourceHostMemcpySizeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
-}
-
-void unmarshal_VkSubresourceHostMemcpySizeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkSubresourceHostMemcpySizeEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
-}
-
-void marshal_VkHostImageCopyDevicePerformanceQueryEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->optimalDeviceAccess, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->identicalMemoryLayout, sizeof(VkBool32));
-}
-
-void unmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkHostImageCopyDevicePerformanceQueryEXT* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->optimalDeviceAccess, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryLayout, sizeof(VkBool32));
-}
-
-#endif
#ifdef VK_EXT_texel_buffer_alignment
void marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream, VkStructureType rootType,
@@ -14434,31 +15380,222 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ marshal_VkPhysicalDeviceVulkan14Features(
vkStream, rootType,
- reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ marshal_VkPhysicalDeviceVulkan14Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ marshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ marshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ marshal_VkQueueFamilyGlobalPriorityProperties(
vkStream, rootType,
- reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ marshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- marshal_VkAttachmentSampleCountInfoAMD(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ marshal_VkPhysicalDeviceShaderFloatControls2Features(
vkStream, rootType,
- reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension));
+ reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- marshal_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ marshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
vkStream, rootType,
- reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension));
+ reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ marshal_VkPhysicalDeviceLineRasterizationFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ marshal_VkPhysicalDeviceLineRasterizationProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ marshal_VkPipelineRasterizationLineStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ marshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ marshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ marshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ marshal_VkPhysicalDeviceIndexTypeUint8Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ marshal_VkPhysicalDeviceMaintenance5Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ marshal_VkPhysicalDeviceMaintenance5Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ marshal_VkPipelineCreateFlags2CreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ marshal_VkBufferUsageFlags2CreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ marshal_VkPhysicalDevicePushDescriptorProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ marshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ marshal_VkRenderingAttachmentLocationInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ marshal_VkRenderingInputAttachmentIndexInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ marshal_VkPhysicalDeviceMaintenance6Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ marshal_VkPhysicalDeviceMaintenance6Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ marshal_VkBindMemoryStatus(
+ vkStream, rootType, reinterpret_cast<const VkBindMemoryStatus*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ marshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ marshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ marshal_VkPhysicalDevicePipelineRobustnessProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ marshal_VkPipelineRobustnessCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ marshal_VkPhysicalDeviceHostImageCopyFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ marshal_VkPhysicalDeviceHostImageCopyProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ marshal_VkSubresourceHostMemcpySize(
+ vkStream, rootType,
+ reinterpret_cast<const VkSubresourceHostMemcpySize*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ marshal_VkHostImageCopyDevicePerformanceQuery(
+ vkStream, rootType,
+ reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(structExtension));
break;
}
#endif
@@ -14478,64 +15615,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- marshal_VkQueueFamilyCheckpointProperties2NV(
- vkStream, rootType,
- reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension));
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- marshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- marshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(
- structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- marshal_VkPipelineCreateFlags2CreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- marshal_VkBufferUsageFlags2CreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension));
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- marshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- marshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- marshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension));
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
marshal_VkNativeBufferANDROID(
@@ -14717,6 +15796,13 @@
}
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension));
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -14750,33 +15836,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
- structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- marshal_VkSubresourceHostMemcpySizeEXT(
- vkStream, rootType,
- reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension));
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- marshal_VkHostImageCopyDevicePerformanceQueryEXT(
- vkStream, rootType,
- reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension));
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
@@ -15673,31 +16732,218 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ unmarshal_VkPhysicalDeviceVulkan14Features(
vkStream, rootType,
- reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ reinterpret_cast<VkPhysicalDeviceVulkan14Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceVulkan14Properties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVulkan14Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ unmarshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ unmarshal_VkQueueFamilyGlobalPriorityProperties(
vkStream, rootType,
- reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ reinterpret_cast<VkQueueFamilyGlobalPriorityProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- unmarshal_VkAttachmentSampleCountInfoAMD(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderFloatControls2Features(
vkStream, rootType,
- reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ reinterpret_cast<VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- unmarshal_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
vkStream, rootType,
- reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ unmarshal_VkPhysicalDeviceLineRasterizationFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceLineRasterizationProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ unmarshal_VkPipelineRasterizationLineStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationLineStateCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ unmarshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ unmarshal_VkPhysicalDeviceIndexTypeUint8Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ unmarshal_VkPhysicalDeviceMaintenance5Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceMaintenance5Properties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ unmarshal_VkPipelineCreateFlags2CreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineCreateFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ unmarshal_VkBufferUsageFlags2CreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkBufferUsageFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ unmarshal_VkPhysicalDevicePushDescriptorProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePushDescriptorProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ unmarshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ unmarshal_VkRenderingAttachmentLocationInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderingAttachmentLocationInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ unmarshal_VkRenderingInputAttachmentIndexInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderingInputAttachmentIndexInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ unmarshal_VkPhysicalDeviceMaintenance6Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceMaintenance6Properties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ unmarshal_VkBindMemoryStatus(
+ vkStream, rootType, reinterpret_cast<VkBindMemoryStatus*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ unmarshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ unmarshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ unmarshal_VkPhysicalDevicePipelineRobustnessProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ unmarshal_VkPipelineRobustnessCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRobustnessCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ unmarshal_VkPhysicalDeviceHostImageCopyFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceHostImageCopyProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ unmarshal_VkSubresourceHostMemcpySize(
+ vkStream, rootType,
+ reinterpret_cast<VkSubresourceHostMemcpySize*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ unmarshal_VkHostImageCopyDevicePerformanceQuery(
+ vkStream, rootType,
+ reinterpret_cast<VkHostImageCopyDevicePerformanceQuery*>(structExtension_out));
break;
}
#endif
@@ -15717,63 +16963,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- unmarshal_VkQueueFamilyCheckpointProperties2NV(
- vkStream, rootType,
- reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- vkStream, rootType,
- reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- vkStream, rootType,
- reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- unmarshal_VkPipelineCreateFlags2CreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- unmarshal_VkBufferUsageFlags2CreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- unmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- vkStream, rootType,
- reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- unmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- vkStream, rootType,
- reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- unmarshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension_out));
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
unmarshal_VkNativeBufferANDROID(
@@ -15952,6 +17141,13 @@
}
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -15984,32 +17180,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- vkStream, rootType,
- reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- vkStream, rootType,
- reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- unmarshal_VkSubresourceHostMemcpySizeEXT(
- vkStream, rootType,
- reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- unmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
- vkStream, rootType,
- reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
@@ -16916,6 +18086,17 @@
return "OP_vkCopyImageToMemoryEXT";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdSetRenderingAttachmentLocations: {
+ return "OP_vkCmdSetRenderingAttachmentLocations";
+ }
+ case OP_vkCopyImageToMemory: {
+ return "OP_vkCopyImageToMemory";
+ }
+ case OP_vkCmdBindIndexBuffer2: {
+ return "OP_vkCmdBindIndexBuffer2";
+ }
+#endif
#ifdef VK_EXT_extended_dynamic_state2
case OP_vkCmdSetPatchControlPointsEXT: {
return "OP_vkCmdSetPatchControlPointsEXT";
@@ -16941,11 +18122,21 @@
return "OP_vkCollectDescriptorPoolIdsGOOGLE";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkGetRenderingAreaGranularity: {
+ return "OP_vkGetRenderingAreaGranularity";
+ }
+#endif
#ifdef VK_VERSION_1_3
case OP_vkCmdCopyImageToBuffer2: {
return "OP_vkCmdCopyImageToBuffer2";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkGetDeviceImageSubresourceLayout: {
+ return "OP_vkGetDeviceImageSubresourceLayout";
+ }
+#endif
#ifdef VK_EXT_extended_dynamic_state
case OP_vkCmdSetDepthWriteEnableEXT: {
return "OP_vkCmdSetDepthWriteEnableEXT";
@@ -16997,6 +18188,11 @@
return "OP_vkCmdSetDepthBoundsTestEnableEXT";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCopyImageToImage: {
+ return "OP_vkCopyImageToImage";
+ }
+#endif
#ifdef VK_EXT_host_image_copy
case OP_vkCopyImageToImageEXT: {
return "OP_vkCopyImageToImageEXT";
@@ -17010,11 +18206,6 @@
return "OP_vkCmdSetCullMode";
}
#endif
-#ifdef VK_KHR_synchronization2
- case OP_vkCmdWriteBufferMarker2AMD: {
- return "OP_vkCmdWriteBufferMarker2AMD";
- }
-#endif
#ifdef VK_VERSION_1_2
case OP_vkWaitSemaphores: {
return "OP_vkWaitSemaphores";
@@ -17030,6 +18221,14 @@
return "OP_vkCmdCopyImage2KHR";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkUnmapMemory2: {
+ return "OP_vkUnmapMemory2";
+ }
+ case OP_vkCmdPushDescriptorSetWithTemplate: {
+ return "OP_vkCmdPushDescriptorSetWithTemplate";
+ }
+#endif
#ifdef VK_VERSION_1_2
case OP_vkGetBufferOpaqueCaptureAddress: {
return "OP_vkGetBufferOpaqueCaptureAddress";
@@ -17056,6 +18255,11 @@
return "OP_vkCmdBeginRenderPass2";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdSetLineStipple: {
+ return "OP_vkCmdSetLineStipple";
+ }
+#endif
#ifdef VK_VERSION_1_3
case OP_vkCmdSetStencilOp: {
return "OP_vkCmdSetStencilOp";
@@ -17149,6 +18353,13 @@
case OP_vkCmdWriteTimestamp2: {
return "OP_vkCmdWriteTimestamp2";
}
+#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdPushDescriptorSet: {
+ return "OP_vkCmdPushDescriptorSet";
+ }
+#endif
+#ifdef VK_VERSION_1_3
case OP_vkCmdCopyImage2: {
return "OP_vkCmdCopyImage2";
}
@@ -17176,6 +18387,11 @@
return "OP_vkResetQueryPool";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkTransitionImageLayout: {
+ return "OP_vkTransitionImageLayout";
+ }
+#endif
#ifdef VK_KHR_copy_commands2
case OP_vkCmdCopyImageToBuffer2KHR: {
return "OP_vkCmdCopyImageToBuffer2KHR";
@@ -17230,6 +18446,13 @@
case OP_vkCreatePrivateDataSlot: {
return "OP_vkCreatePrivateDataSlot";
}
+#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCopyMemoryToImage: {
+ return "OP_vkCopyMemoryToImage";
+ }
+#endif
+#ifdef VK_VERSION_1_3
case OP_vkCmdSetPrimitiveTopology: {
return "OP_vkCmdSetPrimitiveTopology";
}
@@ -17282,6 +18505,17 @@
return "OP_vkGetPipelineExecutablePropertiesKHR";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkGetImageSubresourceLayout2: {
+ return "OP_vkGetImageSubresourceLayout2";
+ }
+ case OP_vkCmdPushDescriptorSet2: {
+ return "OP_vkCmdPushDescriptorSet2";
+ }
+ case OP_vkMapMemory2: {
+ return "OP_vkMapMemory2";
+ }
+#endif
#ifdef VK_KHR_synchronization2
case OP_vkCmdSetEvent2KHR: {
return "OP_vkCmdSetEvent2KHR";
@@ -17330,6 +18564,11 @@
return "OP_vkCmdBeginQueryIndexedEXT";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdPushConstants2: {
+ return "OP_vkCmdPushConstants2";
+ }
+#endif
#ifdef VK_VERSION_1_3
case OP_vkCmdSetRasterizerDiscardEnable: {
return "OP_vkCmdSetRasterizerDiscardEnable";
@@ -17350,6 +18589,11 @@
return "OP_vkCmdEndQueryIndexedEXT";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdBindDescriptorSets2: {
+ return "OP_vkCmdBindDescriptorSets2";
+ }
+#endif
#ifdef VK_EXT_tooling_info
case OP_vkGetPhysicalDeviceToolPropertiesEXT: {
return "OP_vkGetPhysicalDeviceToolPropertiesEXT";
@@ -17378,11 +18622,21 @@
return "OP_vkCmdResetEvent2KHR";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdPushDescriptorSetWithTemplate2: {
+ return "OP_vkCmdPushDescriptorSetWithTemplate2";
+ }
+#endif
#ifdef VK_EXT_transform_feedback
case OP_vkCmdDrawIndirectByteCountEXT: {
return "OP_vkCmdDrawIndirectByteCountEXT";
}
#endif
+#ifdef VK_VERSION_1_4
+ case OP_vkCmdSetRenderingInputAttachmentIndices: {
+ return "OP_vkCmdSetRenderingInputAttachmentIndices";
+ }
+#endif
#ifdef VK_KHR_buffer_device_address
case OP_vkGetBufferOpaqueCaptureAddressKHR: {
return "OP_vkGetBufferOpaqueCaptureAddressKHR";
@@ -17416,11 +18670,6 @@
return "OP_vkGetPrivateDataEXT";
}
#endif
-#ifdef VK_KHR_synchronization2
- case OP_vkGetQueueCheckpointData2NV: {
- return "OP_vkGetQueueCheckpointData2NV";
- }
-#endif
#ifdef VK_GOOGLE_gfxstream
case OP_vkQueueSubmitAsync2GOOGLE: {
return "OP_vkQueueSubmitAsync2GOOGLE";
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.h b/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
index d949a16..56a2f14 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -2202,6 +2202,398 @@
#define OP_vkGetDeviceImageMemoryRequirements 282480635
#define OP_vkGetDeviceImageSparseMemoryRequirements 233707261
#endif
+#ifdef VK_VERSION_1_4
+void marshal_VkPhysicalDeviceVulkan14Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVulkan14Features(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceVulkan14Features* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceVulkan14Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVulkan14Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVulkan14Properties* forUnmarshaling);
+
+void marshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfo* forMarshaling);
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueGlobalPriorityCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceGlobalPriorityQueryFeatures* forUnmarshaling);
+
+void marshal_VkQueueFamilyGlobalPriorityProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityProperties* forMarshaling);
+
+void unmarshal_VkQueueFamilyGlobalPriorityProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyGlobalPriorityProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderSubgroupRotateFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderFloatControls2Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderFloatControls2Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderFloatControls2Features* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderExpectAssumeFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceLineRasterizationFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceLineRasterizationFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLineRasterizationFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceLineRasterizationProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceLineRasterizationProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLineRasterizationProperties* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationLineStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationLineStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationLineStateCreateInfo* forUnmarshaling);
+
+#define OP_vkCmdSetLineStipple 235403148
+void marshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexAttributeDivisorProperties* forUnmarshaling);
+
+void marshal_VkVertexInputBindingDivisorDescription(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescription* forMarshaling);
+
+void unmarshal_VkVertexInputBindingDivisorDescription(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVertexInputBindingDivisorDescription* forUnmarshaling);
+
+void marshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineVertexInputDivisorStateCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexAttributeDivisorFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceIndexTypeUint8Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceIndexTypeUint8Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceIndexTypeUint8Features* forUnmarshaling);
+
+void marshal_VkMemoryMapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryMapInfo* forMarshaling);
+
+void unmarshal_VkMemoryMapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryMapInfo* forUnmarshaling);
+
+void marshal_VkMemoryUnmapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryUnmapInfo* forMarshaling);
+
+void unmarshal_VkMemoryUnmapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryUnmapInfo* forUnmarshaling);
+
+#define OP_vkMapMemory2 269932043
+#define OP_vkUnmapMemory2 229872812
+void marshal_VkPhysicalDeviceMaintenance5Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance5Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance5Features* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMaintenance5Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance5Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance5Properties* forUnmarshaling);
+
+void marshal_VkRenderingAreaInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAreaInfo* forMarshaling);
+
+void unmarshal_VkRenderingAreaInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingAreaInfo* forUnmarshaling);
+
+void marshal_VkImageSubresource2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource2* forMarshaling);
+
+void unmarshal_VkImageSubresource2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresource2* forUnmarshaling);
+
+void marshal_VkDeviceImageSubresourceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* forMarshaling);
+
+void unmarshal_VkDeviceImageSubresourceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceImageSubresourceInfo* forUnmarshaling);
+
+void marshal_VkSubresourceLayout2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout2* forMarshaling);
+
+void unmarshal_VkSubresourceLayout2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubresourceLayout2* forUnmarshaling);
+
+void marshal_VkPipelineCreateFlags2CreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineCreateFlags2CreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineCreateFlags2CreateInfo* forUnmarshaling);
+
+void marshal_VkBufferUsageFlags2CreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* forMarshaling);
+
+void unmarshal_VkBufferUsageFlags2CreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferUsageFlags2CreateInfo* forUnmarshaling);
+
+#define OP_vkCmdBindIndexBuffer2 206158434
+#define OP_vkGetRenderingAreaGranularity 214660941
+#define OP_vkGetDeviceImageSubresourceLayout 216549053
+#define OP_vkGetImageSubresourceLayout2 269545412
+void marshal_VkPhysicalDevicePushDescriptorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePushDescriptorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePushDescriptorProperties* forUnmarshaling);
+
+#define OP_vkCmdPushDescriptorSet 246922559
+#define OP_vkCmdPushDescriptorSetWithTemplate 229886695
+void marshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* forUnmarshaling);
+
+void marshal_VkRenderingAttachmentLocationInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* forMarshaling);
+
+void unmarshal_VkRenderingAttachmentLocationInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingAttachmentLocationInfo* forUnmarshaling);
+
+void marshal_VkRenderingInputAttachmentIndexInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingInputAttachmentIndexInfo* forMarshaling);
+
+void unmarshal_VkRenderingInputAttachmentIndexInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingInputAttachmentIndexInfo* forUnmarshaling);
+
+#define OP_vkCmdSetRenderingAttachmentLocations 204730753
+#define OP_vkCmdSetRenderingInputAttachmentIndices 285610580
+void marshal_VkPhysicalDeviceMaintenance6Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance6Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance6Features* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMaintenance6Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance6Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance6Properties* forUnmarshaling);
+
+void marshal_VkBindMemoryStatus(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindMemoryStatus* forMarshaling);
+
+void unmarshal_VkBindMemoryStatus(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindMemoryStatus* forUnmarshaling);
+
+void marshal_VkBindDescriptorSetsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* forMarshaling);
+
+void unmarshal_VkBindDescriptorSetsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindDescriptorSetsInfo* forUnmarshaling);
+
+void marshal_VkPushConstantsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantsInfo* forMarshaling);
+
+void unmarshal_VkPushConstantsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushConstantsInfo* forUnmarshaling);
+
+void marshal_VkPushDescriptorSetInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* forMarshaling);
+
+void unmarshal_VkPushDescriptorSetInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushDescriptorSetInfo* forUnmarshaling);
+
+void marshal_VkPushDescriptorSetWithTemplateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* forMarshaling);
+
+void unmarshal_VkPushDescriptorSetWithTemplateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushDescriptorSetWithTemplateInfo* forUnmarshaling);
+
+#define OP_vkCmdBindDescriptorSets2 281461882
+#define OP_vkCmdPushConstants2 275905655
+#define OP_vkCmdPushDescriptorSet2 269912858
+#define OP_vkCmdPushDescriptorSetWithTemplate2 285015421
+void marshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineProtectedAccessFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineRobustnessFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDevicePipelineRobustnessProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineRobustnessProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineRobustnessProperties* forUnmarshaling);
+
+void marshal_VkPipelineRobustnessCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineRobustnessCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRobustnessCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceHostImageCopyFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceHostImageCopyFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceHostImageCopyFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceHostImageCopyProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceHostImageCopyProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceHostImageCopyProperties* forUnmarshaling);
+
+void marshal_VkMemoryToImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryToImageCopy* forMarshaling);
+
+void unmarshal_VkMemoryToImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryToImageCopy* forUnmarshaling);
+
+void marshal_VkImageToMemoryCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageToMemoryCopy* forMarshaling);
+
+void unmarshal_VkImageToMemoryCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageToMemoryCopy* forUnmarshaling);
+
+void marshal_VkCopyMemoryToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* forMarshaling);
+
+void unmarshal_VkCopyMemoryToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyMemoryToImageInfo* forUnmarshaling);
+
+void marshal_VkCopyImageToMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* forMarshaling);
+
+void unmarshal_VkCopyImageToMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageToMemoryInfo* forUnmarshaling);
+
+void marshal_VkCopyImageToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToImageInfo* forMarshaling);
+
+void unmarshal_VkCopyImageToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageToImageInfo* forUnmarshaling);
+
+void marshal_VkHostImageLayoutTransitionInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* forMarshaling);
+
+void unmarshal_VkHostImageLayoutTransitionInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkHostImageLayoutTransitionInfo* forUnmarshaling);
+
+void marshal_VkSubresourceHostMemcpySize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* forMarshaling);
+
+void unmarshal_VkSubresourceHostMemcpySize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubresourceHostMemcpySize* forUnmarshaling);
+
+void marshal_VkHostImageCopyDevicePerformanceQuery(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageCopyDevicePerformanceQuery* forMarshaling);
+
+void unmarshal_VkHostImageCopyDevicePerformanceQuery(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkHostImageCopyDevicePerformanceQuery* forUnmarshaling);
+
+#define OP_vkCopyMemoryToImage 263029492
+#define OP_vkCopyImageToMemory 204990977
+#define OP_vkCopyImageToImage 223491795
+#define OP_vkTransitionImageLayout 252133608
+#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(marshal_VkRenderingInfo, marshal_VkRenderingInfoKHR)
@@ -2231,41 +2623,6 @@
#define OP_vkCmdBeginRenderingKHR 298092805
#define OP_vkCmdEndRenderingKHR 200651584
-void marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling);
-
-void unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling);
-
-void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling);
-
-void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling);
-
-void marshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling);
-
-void unmarshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkAttachmentSampleCountInfoAMD* forUnmarshaling);
-
-DEFINE_ALIAS_FUNCTION(marshal_VkAttachmentSampleCountInfoAMD, marshal_VkAttachmentSampleCountInfoNV)
-
-DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentSampleCountInfoAMD,
- unmarshal_VkAttachmentSampleCountInfoNV)
-
-void marshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling);
-
-void unmarshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkMultiviewPerViewAttributesInfoNVX* forUnmarshaling);
-
#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceFeatures2, marshal_VkPhysicalDeviceFeatures2KHR)
@@ -2876,22 +3233,6 @@
#define OP_vkCmdPipelineBarrier2KHR 201310066
#define OP_vkCmdWriteTimestamp2KHR 252552241
#define OP_vkQueueSubmit2KHR 293024240
-#define OP_vkCmdWriteBufferMarker2AMD 224701394
-void marshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling);
-
-void unmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkQueueFamilyCheckpointProperties2NV* forUnmarshaling);
-
-void marshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling);
-
-void unmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCheckpointData2NV* forUnmarshaling);
-
-#define OP_vkGetQueueCheckpointData2NV 292063036
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
@@ -2989,92 +3330,70 @@
#define OP_vkGetDeviceImageSparseMemoryRequirementsKHR 275585477
#endif
#ifdef VK_KHR_maintenance5
-void marshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5FeaturesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMaintenance5Features,
+ marshal_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceMaintenance5FeaturesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMaintenance5Features,
+ unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void marshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMaintenance5Properties,
+ marshal_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceMaintenance5PropertiesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMaintenance5Properties,
+ unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void marshal_VkRenderingAreaInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkRenderingAreaInfo, marshal_VkRenderingAreaInfoKHR)
-void unmarshal_VkRenderingAreaInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkRenderingAreaInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderingAreaInfo, unmarshal_VkRenderingAreaInfoKHR)
-void marshal_VkImageSubresource2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageSubresource2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceImageSubresourceInfo, marshal_VkDeviceImageSubresourceInfoKHR)
-void unmarshal_VkImageSubresource2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkImageSubresource2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceImageSubresourceInfo,
+ unmarshal_VkDeviceImageSubresourceInfoKHR)
-void marshal_VkDeviceImageSubresourceInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkImageSubresource2, marshal_VkImageSubresource2KHR)
-void unmarshal_VkDeviceImageSubresourceInfoKHR(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceImageSubresourceInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageSubresource2, unmarshal_VkImageSubresource2KHR)
-void marshal_VkSubresourceLayout2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceLayout2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkSubresourceLayout2, marshal_VkSubresourceLayout2KHR)
-void unmarshal_VkSubresourceLayout2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkSubresourceLayout2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSubresourceLayout2, unmarshal_VkSubresourceLayout2KHR)
#define OP_vkCmdBindIndexBuffer2KHR 202856085
#define OP_vkGetRenderingAreaGranularityKHR 238658496
#define OP_vkGetDeviceImageSubresourceLayoutKHR 252830318
#define OP_vkGetImageSubresourceLayout2KHR 243334937
-void marshal_VkPipelineCreateFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineCreateFlags2CreateInfo,
+ marshal_VkPipelineCreateFlags2CreateInfoKHR)
-void unmarshal_VkPipelineCreateFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPipelineCreateFlags2CreateInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineCreateFlags2CreateInfo,
+ unmarshal_VkPipelineCreateFlags2CreateInfoKHR)
-void marshal_VkBufferUsageFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkBufferUsageFlags2CreateInfo,
+ marshal_VkBufferUsageFlags2CreateInfoKHR)
-void unmarshal_VkBufferUsageFlags2CreateInfoKHR(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferUsageFlags2CreateInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferUsageFlags2CreateInfo,
+ unmarshal_VkBufferUsageFlags2CreateInfoKHR)
#endif
#ifdef VK_KHR_line_rasterization
-void marshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceLineRasterizationFeatures,
+ marshal_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceLineRasterizationFeaturesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceLineRasterizationFeatures,
+ unmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void marshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceLineRasterizationProperties,
+ marshal_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceLineRasterizationPropertiesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceLineRasterizationProperties,
+ unmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void marshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineRasterizationLineStateCreateInfo,
+ marshal_VkPipelineRasterizationLineStateCreateInfoKHR)
-void unmarshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPipelineRasterizationLineStateCreateInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineRasterizationLineStateCreateInfo,
+ unmarshal_VkPipelineRasterizationLineStateCreateInfoKHR)
#define OP_vkCmdSetLineStippleKHR 219923286
#endif
@@ -3272,22 +3591,22 @@
VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling);
-DEFINE_ALIAS_FUNCTION(marshal_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkVertexInputBindingDivisorDescription,
marshal_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkVertexInputBindingDivisorDescription,
unmarshal_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineVertexInputDivisorStateCreateInfo,
marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineVertexInputDivisorStateCreateInfo,
unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVertexAttributeDivisorFeatures,
marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures,
unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
#endif
@@ -3328,6 +3647,14 @@
VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling);
+void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling);
+
#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceScalarBlockLayoutFeatures,
@@ -3393,31 +3720,31 @@
#endif
#ifdef VK_EXT_line_rasterization
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceLineRasterizationFeatures,
marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceLineRasterizationFeatures,
unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceLineRasterizationProperties,
marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceLineRasterizationProperties,
unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineRasterizationLineStateCreateInfo,
marshal_VkPipelineRasterizationLineStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineRasterizationLineStateCreateInfo,
unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT)
#define OP_vkCmdSetLineStippleEXT 263855692
#endif
#ifdef VK_EXT_index_type_uint8
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceIndexTypeUint8Features,
marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceIndexTypeUint8Features,
unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
#endif
@@ -3444,81 +3771,62 @@
#define OP_vkCmdSetStencilOpEXT 277159578
#endif
#ifdef VK_EXT_host_image_copy
-void marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceHostImageCopyFeatures,
+ marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceHostImageCopyFeaturesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceHostImageCopyFeatures,
+ unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceHostImageCopyProperties,
+ marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkPhysicalDeviceHostImageCopyPropertiesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceHostImageCopyProperties,
+ unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void marshal_VkMemoryToImageCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkMemoryToImageCopy, marshal_VkMemoryToImageCopyEXT)
-void unmarshal_VkMemoryToImageCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkMemoryToImageCopyEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryToImageCopy, unmarshal_VkMemoryToImageCopyEXT)
-void marshal_VkImageToMemoryCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkImageToMemoryCopy, marshal_VkImageToMemoryCopyEXT)
-void unmarshal_VkImageToMemoryCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkImageToMemoryCopyEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageToMemoryCopy, unmarshal_VkImageToMemoryCopyEXT)
-void marshal_VkCopyMemoryToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyMemoryToImageInfo, marshal_VkCopyMemoryToImageInfoEXT)
-void unmarshal_VkCopyMemoryToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCopyMemoryToImageInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyMemoryToImageInfo, unmarshal_VkCopyMemoryToImageInfoEXT)
-void marshal_VkCopyImageToMemoryInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyImageToMemoryInfo, marshal_VkCopyImageToMemoryInfoEXT)
-void unmarshal_VkCopyImageToMemoryInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCopyImageToMemoryInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyImageToMemoryInfo, unmarshal_VkCopyImageToMemoryInfoEXT)
-void marshal_VkCopyImageToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyImageToImageInfo, marshal_VkCopyImageToImageInfoEXT)
-void unmarshal_VkCopyImageToImageInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkCopyImageToImageInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyImageToImageInfo, unmarshal_VkCopyImageToImageInfoEXT)
-void marshal_VkHostImageLayoutTransitionInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkHostImageLayoutTransitionInfo,
+ marshal_VkHostImageLayoutTransitionInfoEXT)
-void unmarshal_VkHostImageLayoutTransitionInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkHostImageLayoutTransitionInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkHostImageLayoutTransitionInfo,
+ unmarshal_VkHostImageLayoutTransitionInfoEXT)
-void marshal_VkSubresourceHostMemcpySizeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkSubresourceHostMemcpySize, marshal_VkSubresourceHostMemcpySizeEXT)
-void unmarshal_VkSubresourceHostMemcpySizeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkSubresourceHostMemcpySizeEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSubresourceHostMemcpySize,
+ unmarshal_VkSubresourceHostMemcpySizeEXT)
-void marshal_VkHostImageCopyDevicePerformanceQueryEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkHostImageCopyDevicePerformanceQuery,
+ marshal_VkHostImageCopyDevicePerformanceQueryEXT)
-void unmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkHostImageCopyDevicePerformanceQueryEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkHostImageCopyDevicePerformanceQuery,
+ unmarshal_VkHostImageCopyDevicePerformanceQueryEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkSubresourceLayout2KHR, marshal_VkSubresourceLayout2EXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkSubresourceLayout2, marshal_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSubresourceLayout2KHR, unmarshal_VkSubresourceLayout2EXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSubresourceLayout2, unmarshal_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkImageSubresource2KHR, marshal_VkImageSubresource2EXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkImageSubresource2, marshal_VkImageSubresource2EXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkImageSubresource2KHR, unmarshal_VkImageSubresource2EXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageSubresource2, unmarshal_VkImageSubresource2EXT)
#define OP_vkCopyMemoryToImageEXT 218832495
#define OP_vkCopyImageToMemoryEXT 204695490
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp b/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
index 8adca19..2b389da 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
@@ -7290,10 +7290,10 @@
}
#endif
-#ifdef VK_KHR_dynamic_rendering
-void reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+void reservedmarshal_VkPhysicalDeviceVulkan14Features(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr) {
+ const VkPhysicalDeviceVulkan14Features* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
@@ -7302,19 +7302,54 @@
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
- memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- reservedmarshal_VkExtent2D(vkStream, rootType,
- (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupRotate, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupRotateClustered, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderFloatControls2, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderExpectAssume, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->dynamicRenderingLocalRead, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->maintenance6, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineRobustness, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->pushDescriptor, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+void reservedmarshal_VkPhysicalDeviceVulkan14Properties(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr) {
+ const VkPhysicalDeviceVulkan14Properties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
@@ -7323,17 +7358,552 @@
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
- memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->supportsNonZeroFirstInstance, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->dynamicRenderingLocalReadDepthStencilAttachments,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->dynamicRenderingLocalReadMultisampledAttachments,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->blockTexelViewCompatibleMultipleLayers,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxCombinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateClampCombinerInputs,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr,
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessStorageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr,
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessUniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessVertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessImageBehavior*)&forMarshaling->defaultRobustnessImages,
+ sizeof(VkPipelineRobustnessImageBehavior));
+ *ptr += sizeof(VkPipelineRobustnessImageBehavior);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
+ memcpy((*ptr), &cgen_var_0, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pCopySrcLayouts) {
+ memcpy(*ptr, (VkImageLayout*)forMarshaling->pCopySrcLayouts,
+ forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+ *ptr += forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout);
+ }
+ memcpy(*ptr, (uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
+ memcpy((*ptr), &cgen_var_1, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pCopyDstLayouts) {
+ memcpy(*ptr, (VkImageLayout*)forMarshaling->pCopyDstLayouts,
+ forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+ *ptr += forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout);
+ }
+ memcpy(*ptr, (uint8_t*)forMarshaling->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
+ *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkAttachmentSampleCountInfoAMD(
+void reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfo(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling, uint8_t** ptr) {
+ const VkDeviceQueueGlobalPriorityCreateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkQueueGlobalPriority*)&forMarshaling->globalPriority,
+ sizeof(VkQueueGlobalPriority));
+ *ptr += sizeof(VkQueueGlobalPriority);
+}
+
+void reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkQueueFamilyGlobalPriorityProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityProperties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (VkQueueGlobalPriority*)forMarshaling->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE * sizeof(VkQueueGlobalPriority));
+ *ptr += VK_MAX_GLOBAL_PRIORITY_SIZE * sizeof(VkQueueGlobalPriority);
+}
+
+void reservedmarshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupRotate, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSubgroupRotateClustered, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceShaderFloatControls2Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderFloatControls2, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderExpectAssume, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceLineRasterizationFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceLineRasterizationProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedmarshal_VkPipelineRasterizationLineStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkLineRasterizationMode*)&forMarshaling->lineRasterizationMode,
+ sizeof(VkLineRasterizationMode));
+ *ptr += sizeof(VkLineRasterizationMode);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint16_t*)&forMarshaling->lineStipplePattern, sizeof(uint16_t));
+ *ptr += sizeof(uint16_t);
+}
+
+void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxVertexAttribDivisor, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->supportsNonZeroFirstInstance, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkVertexInputBindingDivisorDescription(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescription* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i) {
+ reservedmarshal_VkVertexInputBindingDivisorDescription(
+ vkStream, rootType,
+ (const VkVertexInputBindingDivisorDescription*)(forMarshaling->pVertexBindingDivisors +
+ i),
+ ptr);
+ }
+}
+
+void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceIndexTypeUint8Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8Features* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->indexTypeUint8, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkMemoryMapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryMapInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkMemoryMapFlags*)&forMarshaling->flags, sizeof(VkMemoryMapFlags));
+ *ptr += sizeof(VkMemoryMapFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedmarshal_VkMemoryUnmapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryUnmapInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkMemoryUnmapFlags*)&forMarshaling->flags, sizeof(VkMemoryUnmapFlags));
+ *ptr += sizeof(VkMemoryUnmapFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+}
+
+void reservedmarshal_VkPhysicalDeviceMaintenance5Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceMaintenance5Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Properties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkRenderingAreaInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAreaInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
+ memcpy((*ptr), &cgen_var_0, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pColorAttachmentFormats) {
+ memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats,
+ forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ *ptr += forMarshaling->colorAttachmentCount * sizeof(const VkFormat);
+ }
+ memcpy(*ptr, (VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
+ *ptr += sizeof(VkFormat);
+ memcpy(*ptr, (VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+ *ptr += sizeof(VkFormat);
+}
+
+void reservedmarshal_VkImageSubresource2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource2* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ reservedmarshal_VkImageSubresource(
+ vkStream, rootType, (VkImageSubresource*)(&forMarshaling->imageSubresource), ptr);
+}
+
+void reservedmarshal_VkDeviceImageSubresourceInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ reservedmarshal_VkImageCreateInfo(vkStream, rootType,
+ (const VkImageCreateInfo*)(forMarshaling->pCreateInfo), ptr);
+ reservedmarshal_VkImageSubresource2(
+ vkStream, rootType, (const VkImageSubresource2*)(forMarshaling->pSubresource), ptr);
+}
+
+void reservedmarshal_VkSubresourceLayout2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout2* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ reservedmarshal_VkSubresourceLayout(
+ vkStream, rootType, (VkSubresourceLayout*)(&forMarshaling->subresourceLayout), ptr);
+}
+
+void reservedmarshal_VkPipelineCreateFlags2CreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkPipelineCreateFlags2*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags2));
+ *ptr += sizeof(VkPipelineCreateFlags2);
+}
+
+void reservedmarshal_VkBufferUsageFlags2CreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBufferUsageFlags2*)&forMarshaling->usage, sizeof(VkBufferUsageFlags2));
+ *ptr += sizeof(VkBufferUsageFlags2);
+}
+
+void reservedmarshal_VkPhysicalDevicePushDescriptorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPushDescriptors, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedmarshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->dynamicRenderingLocalRead, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkRenderingAttachmentLocationInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
@@ -7345,23 +7915,20 @@
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
// WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentSamples;
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentLocations;
memcpy((*ptr), &cgen_var_0, 8);
gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pColorAttachmentSamples) {
- memcpy(*ptr, (const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples,
- forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
- *ptr += forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits);
+ if (forMarshaling->pColorAttachmentLocations) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pColorAttachmentLocations,
+ forMarshaling->colorAttachmentCount * sizeof(const uint32_t));
+ *ptr += forMarshaling->colorAttachmentCount * sizeof(const uint32_t);
}
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples,
- sizeof(VkSampleCountFlagBits));
- *ptr += sizeof(VkSampleCountFlagBits);
}
-void reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
+void reservedmarshal_VkRenderingInputAttachmentIndexInfo(
VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling, uint8_t** ptr) {
+ const VkRenderingInputAttachmentIndexInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
@@ -7370,9 +7937,536 @@
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->perViewAttributes, sizeof(VkBool32));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentInputIndices;
+ memcpy((*ptr), &cgen_var_0, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pColorAttachmentInputIndices) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pColorAttachmentInputIndices,
+ forMarshaling->colorAttachmentCount * sizeof(const uint32_t));
+ *ptr += forMarshaling->colorAttachmentCount * sizeof(const uint32_t);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthInputAttachmentIndex;
+ memcpy((*ptr), &cgen_var_1, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pDepthInputAttachmentIndex) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDepthInputAttachmentIndex,
+ sizeof(const uint32_t));
+ *ptr += sizeof(const uint32_t);
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pStencilInputAttachmentIndex;
+ memcpy((*ptr), &cgen_var_2, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pStencilInputAttachmentIndex) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pStencilInputAttachmentIndex,
+ sizeof(const uint32_t));
+ *ptr += sizeof(const uint32_t);
+ }
+}
+
+void reservedmarshal_VkPhysicalDeviceMaintenance6Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->maintenance6, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->perViewAttributesPositionXOnly, sizeof(VkBool32));
+}
+
+void reservedmarshal_VkPhysicalDeviceMaintenance6Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Properties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->blockTexelViewCompatibleMultipleLayers,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxCombinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateClampCombinerInputs,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkBindMemoryStatus(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindMemoryStatus* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkResult*)forMarshaling->pResult, sizeof(VkResult));
+ *ptr += sizeof(VkResult);
+}
+
+void reservedmarshal_VkBindDescriptorSetsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ *ptr += sizeof(VkShaderStageFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (uint32_t*)&forMarshaling->firstSet, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ if (forMarshaling->descriptorSetCount) {
+ uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->descriptorSetCount; ++k) {
+ uint64_t tmpval = get_host_u64_VkDescriptorSet(forMarshaling->pDescriptorSets[k]);
+ memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
+ }
+ }
+ *ptr += 8 * forMarshaling->descriptorSetCount;
+ }
+ memcpy(*ptr, (uint32_t*)&forMarshaling->dynamicOffsetCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicOffsets;
+ memcpy((*ptr), &cgen_var_2, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pDynamicOffsets) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDynamicOffsets,
+ forMarshaling->dynamicOffsetCount * sizeof(const uint32_t));
+ *ptr += forMarshaling->dynamicOffsetCount * sizeof(const uint32_t);
+ }
+}
+
+void reservedmarshal_VkPushConstantsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantsInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ *ptr += sizeof(VkShaderStageFlags);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->size, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (const void*)forMarshaling->pValues, forMarshaling->size * sizeof(const uint8_t));
+ *ptr += forMarshaling->size * sizeof(const uint8_t);
+}
+
+void reservedmarshal_VkPushDescriptorSetInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
+ *ptr += sizeof(VkShaderStageFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (uint32_t*)&forMarshaling->set, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorWriteCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorWriteCount; ++i) {
+ reservedmarshal_VkWriteDescriptorSet(
+ vkStream, rootType, (const VkWriteDescriptorSet*)(forMarshaling->pDescriptorWrites + i),
+ ptr);
+ }
+}
+
+void reservedmarshal_VkPushDescriptorSetWithTemplateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 =
+ get_host_u64_VkDescriptorUpdateTemplate((*&forMarshaling->descriptorUpdateTemplate));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ uint64_t cgen_var_1;
+ *&cgen_var_1 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
+ memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (uint32_t*)&forMarshaling->set, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (const void*)forMarshaling->pData, sizeof(const uint8_t));
+ *ptr += sizeof(const uint8_t);
+}
+
+void reservedmarshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->pipelineRobustness, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDevicePipelineRobustnessProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr,
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessStorageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr,
+ (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessUniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessBufferBehavior*)&forMarshaling->defaultRobustnessVertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessImageBehavior*)&forMarshaling->defaultRobustnessImages,
+ sizeof(VkPipelineRobustnessImageBehavior));
+ *ptr += sizeof(VkPipelineRobustnessImageBehavior);
+}
+
+void reservedmarshal_VkPipelineRobustnessCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkPipelineRobustnessBufferBehavior*)&forMarshaling->storageBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessBufferBehavior*)&forMarshaling->uniformBuffers,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessBufferBehavior*)&forMarshaling->vertexInputs,
+ sizeof(VkPipelineRobustnessBufferBehavior));
+ *ptr += sizeof(VkPipelineRobustnessBufferBehavior);
+ memcpy(*ptr, (VkPipelineRobustnessImageBehavior*)&forMarshaling->images,
+ sizeof(VkPipelineRobustnessImageBehavior));
+ *ptr += sizeof(VkPipelineRobustnessImageBehavior);
+}
+
+void reservedmarshal_VkPhysicalDeviceHostImageCopyFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyFeatures* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPhysicalDeviceHostImageCopyProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyProperties* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
+ memcpy((*ptr), &cgen_var_0, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pCopySrcLayouts) {
+ memcpy(*ptr, (VkImageLayout*)forMarshaling->pCopySrcLayouts,
+ forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+ *ptr += forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout);
+ }
+ memcpy(*ptr, (uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
+ memcpy((*ptr), &cgen_var_1, 8);
+ gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
+ *ptr += 8;
+ if (forMarshaling->pCopyDstLayouts) {
+ memcpy(*ptr, (VkImageLayout*)forMarshaling->pCopyDstLayouts,
+ forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+ *ptr += forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout);
+ }
+ memcpy(*ptr, (uint8_t*)forMarshaling->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
+ *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkMemoryToImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryToImageCopy* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (const void*)forMarshaling->pHostPointer, sizeof(const uint8_t));
+ *ptr += sizeof(const uint8_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
+ reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
+}
+
+void reservedmarshal_VkImageToMemoryCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageToMemoryCopy* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (void*)forMarshaling->pHostPointer, sizeof(uint8_t));
+ *ptr += sizeof(uint8_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
+ reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
+}
+
+void reservedmarshal_VkCopyMemoryToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkHostImageCopyFlags*)&forMarshaling->flags, sizeof(VkHostImageCopyFlags));
+ *ptr += sizeof(VkHostImageCopyFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->dstImage));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkMemoryToImageCopy(
+ vkStream, rootType, (const VkMemoryToImageCopy*)(forMarshaling->pRegions + i), ptr);
+ }
+}
+
+void reservedmarshal_VkCopyImageToMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkHostImageCopyFlags*)&forMarshaling->flags, sizeof(VkHostImageCopyFlags));
+ *ptr += sizeof(VkHostImageCopyFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkImageToMemoryCopy(
+ vkStream, rootType, (const VkImageToMemoryCopy*)(forMarshaling->pRegions + i), ptr);
+ }
+}
+
+void reservedmarshal_VkCopyImageToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToImageInfo* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkHostImageCopyFlags*)&forMarshaling->flags, sizeof(VkHostImageCopyFlags));
+ *ptr += sizeof(VkHostImageCopyFlags);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+ uint64_t cgen_var_1;
+ *&cgen_var_1 = get_host_u64_VkImage((*&forMarshaling->dstImage));
+ memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkImageCopy2(vkStream, rootType,
+ (const VkImageCopy2*)(forMarshaling->pRegions + i), ptr);
+ }
+}
+
+void reservedmarshal_VkHostImageLayoutTransitionInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+ reservedmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
+}
+
+void reservedmarshal_VkSubresourceHostMemcpySize(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* forMarshaling,
+ uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedmarshal_VkHostImageCopyDevicePerformanceQuery(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageCopyDevicePerformanceQuery* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->optimalDeviceAccess, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy(*ptr, (VkBool32*)&forMarshaling->identicalMemoryLayout, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -7662,265 +8756,6 @@
}
#endif
-#ifdef VK_KHR_synchronization2
-void reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2*)&forMarshaling->checkpointExecutionStageMask,
- sizeof(VkPipelineStageFlags2));
- *ptr += sizeof(VkPipelineStageFlags2);
-}
-
-void reservedmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2*)&forMarshaling->stage, sizeof(VkPipelineStageFlags2));
- *ptr += sizeof(VkPipelineStageFlags2);
- // WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
- memcpy((*ptr), &cgen_var_0, 8);
- gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
- *ptr += 8;
- if (forMarshaling->pCheckpointMarker) {
- memcpy(*ptr, (void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
- *ptr += sizeof(uint8_t);
- }
-}
-
-#endif
-#ifdef VK_KHR_maintenance5
-void reservedmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5FeaturesKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
-}
-
-void reservedmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
- sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
- sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
- sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
-}
-
-void reservedmarshal_VkRenderingAreaInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- // WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
- memcpy((*ptr), &cgen_var_0, 8);
- gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
- *ptr += 8;
- if (forMarshaling->pColorAttachmentFormats) {
- memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats,
- forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
- *ptr += forMarshaling->colorAttachmentCount * sizeof(const VkFormat);
- }
- memcpy(*ptr, (VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
- *ptr += sizeof(VkFormat);
- memcpy(*ptr, (VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
- *ptr += sizeof(VkFormat);
-}
-
-void reservedmarshal_VkImageSubresource2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageSubresource2KHR* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresource(
- vkStream, rootType, (VkImageSubresource*)(&forMarshaling->imageSubresource), ptr);
-}
-
-void reservedmarshal_VkDeviceImageSubresourceInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageCreateInfo(vkStream, rootType,
- (const VkImageCreateInfo*)(forMarshaling->pCreateInfo), ptr);
- reservedmarshal_VkImageSubresource2KHR(
- vkStream, rootType, (const VkImageSubresource2KHR*)(forMarshaling->pSubresource), ptr);
-}
-
-void reservedmarshal_VkSubresourceLayout2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceLayout2KHR* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkSubresourceLayout(
- vkStream, rootType, (VkSubresourceLayout*)(&forMarshaling->subresourceLayout), ptr);
-}
-
-void reservedmarshal_VkPipelineCreateFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineCreateFlags2KHR*)&forMarshaling->flags,
- sizeof(VkPipelineCreateFlags2KHR));
- *ptr += sizeof(VkPipelineCreateFlags2KHR);
-}
-
-void reservedmarshal_VkBufferUsageFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBufferUsageFlags2KHR*)&forMarshaling->usage, sizeof(VkBufferUsageFlags2KHR));
- *ptr += sizeof(VkBufferUsageFlags2KHR);
-}
-
-#endif
-#ifdef VK_KHR_line_rasterization
-void reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->rectangularLines, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->bresenhamLines, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->smoothLines, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->stippledRectangularLines, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->stippledBresenhamLines, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->stippledSmoothLines, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
-}
-
-void reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->lineSubPixelPrecisionBits, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
-}
-
-void reservedmarshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkLineRasterizationModeKHR*)&forMarshaling->lineRasterizationMode,
- sizeof(VkLineRasterizationModeKHR));
- *ptr += sizeof(VkLineRasterizationModeKHR);
- memcpy(*ptr, (VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint16_t*)&forMarshaling->lineStipplePattern, sizeof(uint16_t));
- *ptr += sizeof(uint16_t);
-}
-
-#endif
#ifdef VK_ANDROID_native_buffer
void reservedmarshal_VkNativeBufferUsage2ANDROID(VulkanStreamGuest* vkStream,
VkStructureType rootType,
@@ -8349,6 +9184,25 @@
ptr);
}
+void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr) {
+ (void)vkStream;
+ (void)rootType;
+ memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+ uint64_t cgen_var_0;
+ *&cgen_var_0 = get_host_u64_VkImageView((*&forMarshaling->imageView));
+ memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
+ *ptr += 1 * 8;
+ memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
+ *ptr += sizeof(VkImageLayout);
+}
+
#endif
#ifdef VK_EXT_provoking_vertex
void reservedmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
@@ -8421,255 +9275,6 @@
}
#endif
-#ifdef VK_EXT_host_image_copy
-void reservedmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
-}
-
-void reservedmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- // WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
- memcpy((*ptr), &cgen_var_0, 8);
- gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
- *ptr += 8;
- if (forMarshaling->pCopySrcLayouts) {
- memcpy(*ptr, (VkImageLayout*)forMarshaling->pCopySrcLayouts,
- forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
- *ptr += forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout);
- }
- memcpy(*ptr, (uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- // WARNING PTR CHECK
- uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
- memcpy((*ptr), &cgen_var_1, 8);
- gfxstream::aemu::Stream::toBe64((uint8_t*)(*ptr));
- *ptr += 8;
- if (forMarshaling->pCopyDstLayouts) {
- memcpy(*ptr, (VkImageLayout*)forMarshaling->pCopyDstLayouts,
- forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
- *ptr += forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout);
- }
- memcpy(*ptr, (uint8_t*)forMarshaling->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
- *ptr += VK_UUID_SIZE * sizeof(uint8_t);
- memcpy(*ptr, (VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
-}
-
-void reservedmarshal_VkMemoryToImageCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const void*)forMarshaling->pHostPointer, sizeof(const uint8_t));
- *ptr += sizeof(const uint8_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- reservedmarshal_VkImageSubresourceLayers(
- vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
-}
-
-void reservedmarshal_VkImageToMemoryCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (void*)forMarshaling->pHostPointer, sizeof(uint8_t));
- *ptr += sizeof(uint8_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- reservedmarshal_VkImageSubresourceLayers(
- vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
- reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
- reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
-}
-
-void reservedmarshal_VkCopyMemoryToImageInfoEXT(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkHostImageCopyFlagsEXT*)&forMarshaling->flags, sizeof(VkHostImageCopyFlagsEXT));
- *ptr += sizeof(VkHostImageCopyFlagsEXT);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->dstImage));
- memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
- reservedmarshal_VkMemoryToImageCopyEXT(
- vkStream, rootType, (const VkMemoryToImageCopyEXT*)(forMarshaling->pRegions + i), ptr);
- }
-}
-
-void reservedmarshal_VkCopyImageToMemoryInfoEXT(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkHostImageCopyFlagsEXT*)&forMarshaling->flags, sizeof(VkHostImageCopyFlagsEXT));
- *ptr += sizeof(VkHostImageCopyFlagsEXT);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
- memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
- reservedmarshal_VkImageToMemoryCopyEXT(
- vkStream, rootType, (const VkImageToMemoryCopyEXT*)(forMarshaling->pRegions + i), ptr);
- }
-}
-
-void reservedmarshal_VkCopyImageToImageInfoEXT(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* forMarshaling,
- uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkHostImageCopyFlagsEXT*)&forMarshaling->flags, sizeof(VkHostImageCopyFlagsEXT));
- *ptr += sizeof(VkHostImageCopyFlagsEXT);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->srcImage));
- memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkImage((*&forMarshaling->dstImage));
- memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
- reservedmarshal_VkImageCopy2(vkStream, rootType,
- (const VkImageCopy2*)(forMarshaling->pRegions + i), ptr);
- }
-}
-
-void reservedmarshal_VkHostImageLayoutTransitionInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
- memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
- *ptr += 1 * 8;
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- memcpy(*ptr, (VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
- *ptr += sizeof(VkImageLayout);
- reservedmarshal_VkImageSubresourceRange(
- vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
-}
-
-void reservedmarshal_VkSubresourceHostMemcpySizeEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- *ptr += sizeof(VkDeviceSize);
-}
-
-void reservedmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->optimalDeviceAccess, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->identicalMemoryLayout, sizeof(VkBool32));
- *ptr += sizeof(VkBool32);
-}
-
-#endif
#ifdef VK_EXT_texel_buffer_alignment
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
VulkanStreamGuest* vkStream, VkStructureType rootType,
@@ -9920,33 +10525,247 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceVulkan14Features(
vkStream, rootType,
- reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceVulkan14Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension),
ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ reservedmarshal_VkQueueFamilyGlobalPriorityProperties(
vkStream, rootType,
- reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension),
ptr);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- reservedmarshal_VkAttachmentSampleCountInfoAMD(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderFloatControls2Features(
vkStream, rootType,
- reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), ptr);
+ reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
vkStream, rootType,
- reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension), ptr);
+ reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceLineRasterizationFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceLineRasterizationProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ reservedmarshal_VkPipelineRasterizationLineStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceIndexTypeUint8Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceMaintenance5Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceMaintenance5Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ reservedmarshal_VkPipelineCreateFlags2CreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ reservedmarshal_VkBufferUsageFlags2CreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ reservedmarshal_VkPhysicalDevicePushDescriptorProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ reservedmarshal_VkRenderingAttachmentLocationInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ reservedmarshal_VkRenderingInputAttachmentIndexInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceMaintenance6Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceMaintenance6Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ reservedmarshal_VkBindMemoryStatus(
+ vkStream, rootType, reinterpret_cast<const VkBindMemoryStatus*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ reservedmarshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ reservedmarshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ reservedmarshal_VkPhysicalDevicePipelineRobustnessProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ reservedmarshal_VkPipelineRobustnessCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceHostImageCopyFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceHostImageCopyProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(structExtension),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ reservedmarshal_VkSubresourceHostMemcpySize(
+ vkStream, rootType,
+ reinterpret_cast<const VkSubresourceHostMemcpySize*>(structExtension), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ reservedmarshal_VkHostImageCopyDevicePerformanceQuery(
+ vkStream, rootType,
+ reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(structExtension),
+ ptr);
break;
}
#endif
@@ -9968,69 +10787,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
- vkStream, rootType,
- reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
- ptr);
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- reservedmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension),
- ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- reservedmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension),
- ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- reservedmarshal_VkPipelineCreateFlags2CreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension), ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- reservedmarshal_VkBufferUsageFlags2CreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension), ptr);
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension),
- ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension),
- ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- reservedmarshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- vkStream, rootType,
- reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension),
- ptr);
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
reservedmarshal_VkNativeBufferANDROID(
@@ -10230,6 +10986,14 @@
}
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension),
+ ptr);
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -10267,36 +11031,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- reservedmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension),
- ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- reservedmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- vkStream, rootType,
- reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
- structExtension),
- ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- reservedmarshal_VkSubresourceHostMemcpySizeEXT(
- vkStream, rootType,
- reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension), ptr);
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- reservedmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
- vkStream, rootType,
- reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension),
- ptr);
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h b/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
index 237030f..ad06483 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
@@ -1155,6 +1155,205 @@
const VkDeviceImageMemoryRequirements* forMarshaling, uint8_t** ptr);
#endif
+#ifdef VK_VERSION_1_4
+void reservedmarshal_VkPhysicalDeviceVulkan14Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Features* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceVulkan14Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan14Properties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkQueueFamilyGlobalPriorityProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityProperties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupRotateFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceShaderFloatControls2Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloatControls2Features* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderExpectAssumeFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceLineRasterizationFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceLineRasterizationProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationProperties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPipelineRasterizationLineStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorProperties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkVertexInputBindingDivisorDescription(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescription* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceIndexTypeUint8Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8Features* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkMemoryMapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryMapInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkMemoryUnmapInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryUnmapInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceMaintenance5Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Features* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceMaintenance5Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance5Properties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkRenderingAreaInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAreaInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkImageSubresource2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource2* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkDeviceImageSubresourceInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDeviceImageSubresourceInfo* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkSubresourceLayout2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout2* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPipelineCreateFlags2CreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreateFlags2CreateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkBufferUsageFlags2CreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferUsageFlags2CreateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDevicePushDescriptorProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorProperties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkRenderingAttachmentLocationInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAttachmentLocationInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkRenderingInputAttachmentIndexInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingInputAttachmentIndexInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceMaintenance6Features(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Features* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceMaintenance6Properties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance6Properties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkBindMemoryStatus(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindMemoryStatus* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkBindDescriptorSetsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindDescriptorSetsInfo* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkPushConstantsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantsInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPushDescriptorSetInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetInfo* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkPushDescriptorSetWithTemplateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushDescriptorSetWithTemplateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineProtectedAccessFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDevicePipelineRobustnessFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDevicePipelineRobustnessProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineRobustnessProperties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPipelineRobustnessCreateInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRobustnessCreateInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceHostImageCopyFeatures(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyFeatures* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPhysicalDeviceHostImageCopyProperties(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostImageCopyProperties* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkMemoryToImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryToImageCopy* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkImageToMemoryCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageToMemoryCopy* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkCopyMemoryToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToImageInfo* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkCopyImageToMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToMemoryInfo* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkCopyImageToImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToImageInfo* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkHostImageLayoutTransitionInfo(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageLayoutTransitionInfo* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkSubresourceHostMemcpySize(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSubresourceHostMemcpySize* forMarshaling,
+ uint8_t** ptr);
+
+void reservedmarshal_VkHostImageCopyDevicePerformanceQuery(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHostImageCopyDevicePerformanceQuery* forMarshaling, uint8_t** ptr);
+
+#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderingInfo, reservedmarshal_VkRenderingInfoKHR)
@@ -1170,25 +1369,6 @@
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkCommandBufferInheritanceRenderingInfo,
reservedmarshal_VkCommandBufferInheritanceRenderingInfoKHR)
-void reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr);
-
-void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr);
-
-void reservedmarshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling, uint8_t** ptr);
-
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentSampleCountInfoAMD,
- reservedmarshal_VkAttachmentSampleCountInfoNV)
-
-void reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling, uint8_t** ptr);
-
#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceFeatures2,
@@ -1531,13 +1711,6 @@
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSynchronization2Features,
reservedmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR)
-void reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling, uint8_t** ptr);
-
-void reservedmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling, uint8_t** ptr);
-
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
@@ -1589,51 +1762,37 @@
#endif
#ifdef VK_KHR_maintenance5
-void reservedmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5FeaturesKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMaintenance5Features,
+ reservedmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void reservedmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceMaintenance5PropertiesKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMaintenance5Properties,
+ reservedmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void reservedmarshal_VkRenderingAreaInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkRenderingAreaInfoKHR* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderingAreaInfo, reservedmarshal_VkRenderingAreaInfoKHR)
-void reservedmarshal_VkImageSubresource2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageSubresource2KHR* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceImageSubresourceInfo,
+ reservedmarshal_VkDeviceImageSubresourceInfoKHR)
-void reservedmarshal_VkDeviceImageSubresourceInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkDeviceImageSubresourceInfoKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageSubresource2, reservedmarshal_VkImageSubresource2KHR)
-void reservedmarshal_VkSubresourceLayout2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceLayout2KHR* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubresourceLayout2, reservedmarshal_VkSubresourceLayout2KHR)
-void reservedmarshal_VkPipelineCreateFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineCreateFlags2CreateInfoKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineCreateFlags2CreateInfo,
+ reservedmarshal_VkPipelineCreateFlags2CreateInfoKHR)
-void reservedmarshal_VkBufferUsageFlags2CreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkBufferUsageFlags2CreateInfoKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferUsageFlags2CreateInfo,
+ reservedmarshal_VkBufferUsageFlags2CreateInfoKHR)
#endif
#ifdef VK_KHR_line_rasterization
-void reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceLineRasterizationFeatures,
+ reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceLineRasterizationProperties,
+ reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void reservedmarshal_VkPipelineRasterizationLineStateCreateInfoKHR(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoKHR* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineRasterizationLineStateCreateInfo,
+ reservedmarshal_VkPipelineRasterizationLineStateCreateInfoKHR)
#endif
#ifdef VK_ANDROID_native_buffer
@@ -1737,13 +1896,13 @@
VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkVertexInputBindingDivisorDescription,
reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfo,
reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeatures,
reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
#endif
@@ -1768,6 +1927,10 @@
VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling, uint8_t** ptr);
+void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr);
+
#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures,
@@ -1805,18 +1968,18 @@
#endif
#ifdef VK_EXT_line_rasterization
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceLineRasterizationFeatures,
reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceLineRasterizationProperties,
reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineRasterizationLineStateCreateInfo,
reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT)
#endif
#ifdef VK_EXT_index_type_uint8
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceIndexTypeUint8Features,
reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
#endif
@@ -1827,54 +1990,37 @@
#endif
#ifdef VK_EXT_host_image_copy
-void reservedmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyFeaturesEXT* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceHostImageCopyFeatures,
+ reservedmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void reservedmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkPhysicalDeviceHostImageCopyPropertiesEXT* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceHostImageCopyProperties,
+ reservedmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void reservedmarshal_VkMemoryToImageCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkMemoryToImageCopyEXT* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryToImageCopy, reservedmarshal_VkMemoryToImageCopyEXT)
-void reservedmarshal_VkImageToMemoryCopyEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImageToMemoryCopyEXT* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageToMemoryCopy, reservedmarshal_VkImageToMemoryCopyEXT)
-void reservedmarshal_VkCopyMemoryToImageInfoEXT(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyMemoryToImageInfoEXT* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkCopyMemoryToImageInfo,
+ reservedmarshal_VkCopyMemoryToImageInfoEXT)
-void reservedmarshal_VkCopyImageToMemoryInfoEXT(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToMemoryInfoEXT* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkCopyImageToMemoryInfo,
+ reservedmarshal_VkCopyImageToMemoryInfoEXT)
-void reservedmarshal_VkCopyImageToImageInfoEXT(VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToImageInfoEXT* forMarshaling,
- uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkCopyImageToImageInfo,
+ reservedmarshal_VkCopyImageToImageInfoEXT)
-void reservedmarshal_VkHostImageLayoutTransitionInfoEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageLayoutTransitionInfoEXT* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkHostImageLayoutTransitionInfo,
+ reservedmarshal_VkHostImageLayoutTransitionInfoEXT)
-void reservedmarshal_VkSubresourceHostMemcpySizeEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkSubresourceHostMemcpySizeEXT* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubresourceHostMemcpySize,
+ reservedmarshal_VkSubresourceHostMemcpySizeEXT)
-void reservedmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkHostImageCopyDevicePerformanceQueryEXT* forMarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkHostImageCopyDevicePerformanceQuery,
+ reservedmarshal_VkHostImageCopyDevicePerformanceQueryEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubresourceLayout2KHR,
- reservedmarshal_VkSubresourceLayout2EXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubresourceLayout2, reservedmarshal_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageSubresource2KHR,
- reservedmarshal_VkImageSubresource2EXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageSubresource2, reservedmarshal_VkImageSubresource2EXT)
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.cpp b/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
index 6037382..5fa95c1 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -6085,42 +6085,218 @@
}
#endif
-#ifdef VK_KHR_dynamic_rendering
-void transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+#ifdef VK_VERSION_1_4
+void transform_tohost_VkPhysicalDeviceVulkan14Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceVulkan14Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceVulkan14Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Properties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceVulkan14Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Properties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfo(
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfo(
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkQueueFamilyGlobalPriorityProperties(
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkQueueFamilyGlobalPriorityProperties(
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSubgroupRotateFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSubgroupRotateFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderFloatControls2Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloatControls2Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderFloatControls2Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloatControls2Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderExpectAssumeFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderExpectAssumeFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceLineRasterizationFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceLineRasterizationFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceLineRasterizationProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceLineRasterizationProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPipelineRasterizationLineStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPipelineRasterizationLineStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorProperties(
ResourceTracker* resourceTracker,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform) {
+ VkPhysicalDeviceVertexAttributeDivisorProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker,
- (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
}
-void transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+void transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorProperties(
ResourceTracker* resourceTracker,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_fromhost_VkExtent2D(resourceTracker,
- (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
-}
-
-void transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform) {
+ VkPhysicalDeviceVertexAttributeDivisorProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
if (toTransform->pNext) {
@@ -6128,8 +6304,58 @@
}
}
-void transform_tohost_VkAttachmentSampleCountInfoAMD(ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform) {
+void transform_tohost_VkVertexInputBindingDivisorDescription(
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescription* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+}
+
+void transform_fromhost_VkVertexInputBindingDivisorDescription(
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescription* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+}
+
+void transform_tohost_VkPipelineVertexInputDivisorStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pVertexBindingDivisors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDivisorCount; ++i) {
+ transform_tohost_VkVertexInputBindingDivisorDescription(
+ resourceTracker,
+ (VkVertexInputBindingDivisorDescription*)(toTransform->pVertexBindingDivisors +
+ i));
+ }
+ }
+ }
+}
+
+void transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pVertexBindingDivisors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDivisorCount; ++i) {
+ transform_fromhost_VkVertexInputBindingDivisorDescription(
+ resourceTracker,
+ (VkVertexInputBindingDivisorDescription*)(toTransform->pVertexBindingDivisors +
+ i));
+ }
+ }
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVertexAttributeDivisorFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
if (toTransform->pNext) {
@@ -6137,8 +6363,8 @@
}
}
-void transform_fromhost_VkAttachmentSampleCountInfoAMD(
- ResourceTracker* resourceTracker, VkAttachmentSampleCountInfoAMD* toTransform) {
+void transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVertexAttributeDivisorFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
if (toTransform->pNext) {
@@ -6146,8 +6372,8 @@
}
}
-void transform_tohost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform) {
+void transform_tohost_VkPhysicalDeviceIndexTypeUint8Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
if (toTransform->pNext) {
@@ -6155,8 +6381,752 @@
}
}
-void transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform) {
+void transform_fromhost_VkPhysicalDeviceIndexTypeUint8Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkMemoryMapInfo(ResourceTracker* resourceTracker,
+ VkMemoryMapInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkMemoryMapInfo(ResourceTracker* resourceTracker,
+ VkMemoryMapInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkMemoryUnmapInfo(ResourceTracker* resourceTracker,
+ VkMemoryUnmapInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkMemoryUnmapInfo(ResourceTracker* resourceTracker,
+ VkMemoryUnmapInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance5Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance5Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Properties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Properties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkRenderingAreaInfo(ResourceTracker* resourceTracker,
+ VkRenderingAreaInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkRenderingAreaInfo(ResourceTracker* resourceTracker,
+ VkRenderingAreaInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkImageSubresource2(ResourceTracker* resourceTracker,
+ VkImageSubresource2* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_tohost_VkImageSubresource(resourceTracker,
+ (VkImageSubresource*)(&toTransform->imageSubresource));
+}
+
+void transform_fromhost_VkImageSubresource2(ResourceTracker* resourceTracker,
+ VkImageSubresource2* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_fromhost_VkImageSubresource(resourceTracker,
+ (VkImageSubresource*)(&toTransform->imageSubresource));
+}
+
+void transform_tohost_VkDeviceImageSubresourceInfo(ResourceTracker* resourceTracker,
+ VkDeviceImageSubresourceInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform->pCreateInfo) {
+ resourceTracker->transformImpl_VkImageCreateInfo_tohost(toTransform->pCreateInfo, 1);
+ transform_tohost_VkImageCreateInfo(resourceTracker,
+ (VkImageCreateInfo*)(toTransform->pCreateInfo));
+ }
+ if (toTransform->pSubresource) {
+ transform_tohost_VkImageSubresource2(resourceTracker,
+ (VkImageSubresource2*)(toTransform->pSubresource));
+ }
+}
+
+void transform_fromhost_VkDeviceImageSubresourceInfo(ResourceTracker* resourceTracker,
+ VkDeviceImageSubresourceInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform->pCreateInfo) {
+ resourceTracker->transformImpl_VkImageCreateInfo_fromhost(toTransform->pCreateInfo, 1);
+ transform_fromhost_VkImageCreateInfo(resourceTracker,
+ (VkImageCreateInfo*)(toTransform->pCreateInfo));
+ }
+ if (toTransform->pSubresource) {
+ transform_fromhost_VkImageSubresource2(resourceTracker,
+ (VkImageSubresource2*)(toTransform->pSubresource));
+ }
+}
+
+void transform_tohost_VkSubresourceLayout2(ResourceTracker* resourceTracker,
+ VkSubresourceLayout2* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_tohost_VkSubresourceLayout(resourceTracker,
+ (VkSubresourceLayout*)(&toTransform->subresourceLayout));
+}
+
+void transform_fromhost_VkSubresourceLayout2(ResourceTracker* resourceTracker,
+ VkSubresourceLayout2* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_fromhost_VkSubresourceLayout(resourceTracker,
+ (VkSubresourceLayout*)(&toTransform->subresourceLayout));
+}
+
+void transform_tohost_VkPipelineCreateFlags2CreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPipelineCreateFlags2CreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkBufferUsageFlags2CreateInfo(ResourceTracker* resourceTracker,
+ VkBufferUsageFlags2CreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkBufferUsageFlags2CreateInfo(ResourceTracker* resourceTracker,
+ VkBufferUsageFlags2CreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDevicePushDescriptorProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDevicePushDescriptorProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkRenderingAttachmentLocationInfo(
+ ResourceTracker* resourceTracker, VkRenderingAttachmentLocationInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkRenderingAttachmentLocationInfo(
+ ResourceTracker* resourceTracker, VkRenderingAttachmentLocationInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkRenderingInputAttachmentIndexInfo(
+ ResourceTracker* resourceTracker, VkRenderingInputAttachmentIndexInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkRenderingInputAttachmentIndexInfo(
+ ResourceTracker* resourceTracker, VkRenderingInputAttachmentIndexInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance6Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance6Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Features* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance6Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Properties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance6Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Properties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkBindMemoryStatus(ResourceTracker* resourceTracker,
+ VkBindMemoryStatus* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkBindMemoryStatus(ResourceTracker* resourceTracker,
+ VkBindMemoryStatus* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkBindDescriptorSetsInfo(ResourceTracker* resourceTracker,
+ VkBindDescriptorSetsInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkBindDescriptorSetsInfo(ResourceTracker* resourceTracker,
+ VkBindDescriptorSetsInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPushConstantsInfo(ResourceTracker* resourceTracker,
+ VkPushConstantsInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPushConstantsInfo(ResourceTracker* resourceTracker,
+ VkPushConstantsInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPushDescriptorSetInfo(ResourceTracker* resourceTracker,
+ VkPushDescriptorSetInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pDescriptorWrites) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorWriteCount; ++i) {
+ transform_tohost_VkWriteDescriptorSet(
+ resourceTracker, (VkWriteDescriptorSet*)(toTransform->pDescriptorWrites + i));
+ }
+ }
+ }
+}
+
+void transform_fromhost_VkPushDescriptorSetInfo(ResourceTracker* resourceTracker,
+ VkPushDescriptorSetInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pDescriptorWrites) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorWriteCount; ++i) {
+ transform_fromhost_VkWriteDescriptorSet(
+ resourceTracker, (VkWriteDescriptorSet*)(toTransform->pDescriptorWrites + i));
+ }
+ }
+ }
+}
+
+void transform_tohost_VkPushDescriptorSetWithTemplateInfo(
+ ResourceTracker* resourceTracker, VkPushDescriptorSetWithTemplateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPushDescriptorSetWithTemplateInfo(
+ ResourceTracker* resourceTracker, VkPushDescriptorSetWithTemplateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDevicePipelineProtectedAccessFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDevicePipelineProtectedAccessFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDevicePipelineRobustnessFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDevicePipelineRobustnessProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPipelineRobustnessCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineRobustnessCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPipelineRobustnessCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineRobustnessCreateInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceHostImageCopyFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeatures* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceHostImageCopyProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyProperties* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkMemoryToImageCopy(ResourceTracker* resourceTracker,
+ VkMemoryToImageCopy* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+ transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_fromhost_VkMemoryToImageCopy(ResourceTracker* resourceTracker,
+ VkMemoryToImageCopy* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+ transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_tohost_VkImageToMemoryCopy(ResourceTracker* resourceTracker,
+ VkImageToMemoryCopy* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+ transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_fromhost_VkImageToMemoryCopy(ResourceTracker* resourceTracker,
+ VkImageToMemoryCopy* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+ transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_tohost_VkCopyMemoryToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyMemoryToImageInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkMemoryToImageCopy(
+ resourceTracker, (VkMemoryToImageCopy*)(toTransform->pRegions + i));
+ }
+ }
+ }
+}
+
+void transform_fromhost_VkCopyMemoryToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyMemoryToImageInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkMemoryToImageCopy(
+ resourceTracker, (VkMemoryToImageCopy*)(toTransform->pRegions + i));
+ }
+ }
+ }
+}
+
+void transform_tohost_VkCopyImageToMemoryInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToMemoryInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkImageToMemoryCopy(
+ resourceTracker, (VkImageToMemoryCopy*)(toTransform->pRegions + i));
+ }
+ }
+ }
+}
+
+void transform_fromhost_VkCopyImageToMemoryInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToMemoryInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkImageToMemoryCopy(
+ resourceTracker, (VkImageToMemoryCopy*)(toTransform->pRegions + i));
+ }
+ }
+ }
+}
+
+void transform_tohost_VkCopyImageToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToImageInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkImageCopy2(resourceTracker,
+ (VkImageCopy2*)(toTransform->pRegions + i));
+ }
+ }
+ }
+}
+
+void transform_fromhost_VkCopyImageToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToImageInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkImageCopy2(resourceTracker,
+ (VkImageCopy2*)(toTransform->pRegions + i));
+ }
+ }
+ }
+}
+
+void transform_tohost_VkHostImageLayoutTransitionInfo(
+ ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_tohost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+}
+
+void transform_fromhost_VkHostImageLayoutTransitionInfo(
+ ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfo* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ transform_fromhost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+}
+
+void transform_tohost_VkSubresourceHostMemcpySize(ResourceTracker* resourceTracker,
+ VkSubresourceHostMemcpySize* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkSubresourceHostMemcpySize(ResourceTracker* resourceTracker,
+ VkSubresourceHostMemcpySize* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkHostImageCopyDevicePerformanceQuery(
+ ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQuery* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkHostImageCopyDevicePerformanceQuery(
+ ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQuery* toTransform) {
(void)resourceTracker;
(void)toTransform;
if (toTransform->pNext) {
@@ -6449,272 +7419,6 @@
}
#endif
-#ifdef VK_KHR_synchronization2
-void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-#endif
-#ifdef VK_KHR_maintenance5
-void transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkRenderingAreaInfoKHR(ResourceTracker* resourceTracker,
- VkRenderingAreaInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkRenderingAreaInfoKHR(ResourceTracker* resourceTracker,
- VkRenderingAreaInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkImageSubresource2KHR(ResourceTracker* resourceTracker,
- VkImageSubresource2KHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_tohost_VkImageSubresource(resourceTracker,
- (VkImageSubresource*)(&toTransform->imageSubresource));
-}
-
-void transform_fromhost_VkImageSubresource2KHR(ResourceTracker* resourceTracker,
- VkImageSubresource2KHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_fromhost_VkImageSubresource(resourceTracker,
- (VkImageSubresource*)(&toTransform->imageSubresource));
-}
-
-void transform_tohost_VkDeviceImageSubresourceInfoKHR(
- ResourceTracker* resourceTracker, VkDeviceImageSubresourceInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform->pCreateInfo) {
- resourceTracker->transformImpl_VkImageCreateInfo_tohost(toTransform->pCreateInfo, 1);
- transform_tohost_VkImageCreateInfo(resourceTracker,
- (VkImageCreateInfo*)(toTransform->pCreateInfo));
- }
- if (toTransform->pSubresource) {
- transform_tohost_VkImageSubresource2KHR(
- resourceTracker, (VkImageSubresource2KHR*)(toTransform->pSubresource));
- }
-}
-
-void transform_fromhost_VkDeviceImageSubresourceInfoKHR(
- ResourceTracker* resourceTracker, VkDeviceImageSubresourceInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform->pCreateInfo) {
- resourceTracker->transformImpl_VkImageCreateInfo_fromhost(toTransform->pCreateInfo, 1);
- transform_fromhost_VkImageCreateInfo(resourceTracker,
- (VkImageCreateInfo*)(toTransform->pCreateInfo));
- }
- if (toTransform->pSubresource) {
- transform_fromhost_VkImageSubresource2KHR(
- resourceTracker, (VkImageSubresource2KHR*)(toTransform->pSubresource));
- }
-}
-
-void transform_tohost_VkSubresourceLayout2KHR(ResourceTracker* resourceTracker,
- VkSubresourceLayout2KHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_tohost_VkSubresourceLayout(resourceTracker,
- (VkSubresourceLayout*)(&toTransform->subresourceLayout));
-}
-
-void transform_fromhost_VkSubresourceLayout2KHR(ResourceTracker* resourceTracker,
- VkSubresourceLayout2KHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_fromhost_VkSubresourceLayout(resourceTracker,
- (VkSubresourceLayout*)(&toTransform->subresourceLayout));
-}
-
-void transform_tohost_VkPipelineCreateFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkBufferUsageFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkBufferUsageFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-#endif
-#ifdef VK_KHR_line_rasterization
-void transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkPipelineRasterizationLineStateCreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPipelineRasterizationLineStateCreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoKHR* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-#endif
#ifdef VK_ANDROID_native_buffer
void transform_tohost_VkNativeBufferUsage2ANDROID(ResourceTracker* resourceTracker,
VkNativeBufferUsage2ANDROID* toTransform) {
@@ -7166,6 +7870,24 @@
resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
}
+void transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
#endif
#ifdef VK_EXT_provoking_vertex
void transform_tohost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
@@ -7247,256 +7969,6 @@
}
#endif
-#ifdef VK_EXT_host_image_copy
-void transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkMemoryToImageCopyEXT(ResourceTracker* resourceTracker,
- VkMemoryToImageCopyEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_tohost_VkImageSubresourceLayers(
- resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
- transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
- transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
-}
-
-void transform_fromhost_VkMemoryToImageCopyEXT(ResourceTracker* resourceTracker,
- VkMemoryToImageCopyEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_fromhost_VkImageSubresourceLayers(
- resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
- transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
- transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
-}
-
-void transform_tohost_VkImageToMemoryCopyEXT(ResourceTracker* resourceTracker,
- VkImageToMemoryCopyEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_tohost_VkImageSubresourceLayers(
- resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
- transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
- transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
-}
-
-void transform_fromhost_VkImageToMemoryCopyEXT(ResourceTracker* resourceTracker,
- VkImageToMemoryCopyEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_fromhost_VkImageSubresourceLayers(
- resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
- transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
- transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
-}
-
-void transform_tohost_VkCopyMemoryToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyMemoryToImageInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform) {
- if (toTransform->pRegions) {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
- transform_tohost_VkMemoryToImageCopyEXT(
- resourceTracker, (VkMemoryToImageCopyEXT*)(toTransform->pRegions + i));
- }
- }
- }
-}
-
-void transform_fromhost_VkCopyMemoryToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyMemoryToImageInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform) {
- if (toTransform->pRegions) {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
- transform_fromhost_VkMemoryToImageCopyEXT(
- resourceTracker, (VkMemoryToImageCopyEXT*)(toTransform->pRegions + i));
- }
- }
- }
-}
-
-void transform_tohost_VkCopyImageToMemoryInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToMemoryInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform) {
- if (toTransform->pRegions) {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
- transform_tohost_VkImageToMemoryCopyEXT(
- resourceTracker, (VkImageToMemoryCopyEXT*)(toTransform->pRegions + i));
- }
- }
- }
-}
-
-void transform_fromhost_VkCopyImageToMemoryInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToMemoryInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform) {
- if (toTransform->pRegions) {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
- transform_fromhost_VkImageToMemoryCopyEXT(
- resourceTracker, (VkImageToMemoryCopyEXT*)(toTransform->pRegions + i));
- }
- }
- }
-}
-
-void transform_tohost_VkCopyImageToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToImageInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform) {
- if (toTransform->pRegions) {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
- transform_tohost_VkImageCopy2(resourceTracker,
- (VkImageCopy2*)(toTransform->pRegions + i));
- }
- }
- }
-}
-
-void transform_fromhost_VkCopyImageToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToImageInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- if (toTransform) {
- if (toTransform->pRegions) {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
- transform_fromhost_VkImageCopy2(resourceTracker,
- (VkImageCopy2*)(toTransform->pRegions + i));
- }
- }
- }
-}
-
-void transform_tohost_VkHostImageLayoutTransitionInfoEXT(
- ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_tohost_VkImageSubresourceRange(
- resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
-}
-
-void transform_fromhost_VkHostImageLayoutTransitionInfoEXT(
- ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
- transform_fromhost_VkImageSubresourceRange(
- resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
-}
-
-void transform_tohost_VkSubresourceHostMemcpySizeEXT(ResourceTracker* resourceTracker,
- VkSubresourceHostMemcpySizeEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkSubresourceHostMemcpySizeEXT(
- ResourceTracker* resourceTracker, VkSubresourceHostMemcpySizeEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT(
- ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT(
- ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-#endif
#ifdef VK_EXT_texel_buffer_alignment
void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
ResourceTracker* resourceTracker,
@@ -8670,29 +9142,210 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ transform_tohost_VkPhysicalDeviceVulkan14Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan14Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceVulkan14Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan14Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ transform_tohost_VkDeviceQueueGlobalPriorityCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ transform_tohost_VkQueueFamilyGlobalPriorityProperties(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyGlobalPriorityProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- transform_tohost_VkAttachmentSampleCountInfoAMD(
- resourceTracker,
- reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderFloatControls2Features(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- transform_tohost_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderExpectAssumeFeatures(
resourceTracker,
- reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ transform_tohost_VkPhysicalDeviceLineRasterizationFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceLineRasterizationProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ transform_tohost_VkPipelineRasterizationLineStateCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationLineStateCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ transform_tohost_VkPipelineVertexInputDivisorStateCreateInfo(
+ resourceTracker, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ transform_tohost_VkPhysicalDeviceIndexTypeUint8Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ transform_tohost_VkPhysicalDeviceMaintenance5Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceMaintenance5Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ transform_tohost_VkPipelineCreateFlags2CreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCreateFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ transform_tohost_VkBufferUsageFlags2CreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkBufferUsageFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ transform_tohost_VkPhysicalDevicePushDescriptorProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePushDescriptorProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ transform_tohost_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ transform_tohost_VkRenderingAttachmentLocationInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderingAttachmentLocationInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ transform_tohost_VkRenderingInputAttachmentIndexInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderingInputAttachmentIndexInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ transform_tohost_VkPhysicalDeviceMaintenance6Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceMaintenance6Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ transform_tohost_VkBindMemoryStatus(
+ resourceTracker, reinterpret_cast<VkBindMemoryStatus*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ transform_tohost_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ transform_tohost_VkPhysicalDevicePipelineRobustnessFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ transform_tohost_VkPhysicalDevicePipelineRobustnessProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ transform_tohost_VkPipelineRobustnessCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRobustnessCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ transform_tohost_VkPhysicalDeviceHostImageCopyFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceHostImageCopyProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ transform_tohost_VkSubresourceHostMemcpySize(
+ resourceTracker,
+ reinterpret_cast<VkSubresourceHostMemcpySize*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ transform_tohost_VkHostImageCopyDevicePerformanceQuery(
+ resourceTracker,
+ reinterpret_cast<VkHostImageCopyDevicePerformanceQuery*>(structExtension_out));
break;
}
#endif
@@ -8712,60 +9365,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- transform_tohost_VkQueueFamilyCheckpointProperties2NV(
- resourceTracker,
- reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- transform_tohost_VkPipelineCreateFlags2CreateInfoKHR(
- resourceTracker,
- reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- transform_tohost_VkBufferUsageFlags2CreateInfoKHR(
- resourceTracker,
- reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- transform_tohost_VkPipelineRasterizationLineStateCreateInfoKHR(
- resourceTracker, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension_out));
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
transform_tohost_VkNativeBufferANDROID(
@@ -8868,6 +9467,12 @@
structExtension_out));
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -8898,32 +9503,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- transform_tohost_VkSubresourceHostMemcpySizeEXT(
- resourceTracker,
- reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT(
- resourceTracker,
- reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
transform_tohost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
@@ -9781,29 +10360,210 @@
break;
}
#endif
-#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
- transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+#ifdef VK_VERSION_1_4
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceVulkan14Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan14Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceVulkan14Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan14Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: {
+ transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
- transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: {
+ transform_fromhost_VkQueueFamilyGlobalPriorityProperties(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyGlobalPriorityProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
- transform_fromhost_VkAttachmentSampleCountInfoAMD(
- resourceTracker,
- reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderFloatControls2Features(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderFloatControls2Features*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
- transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderExpectAssumeFeatures(
resourceTracker,
- reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceLineRasterizationFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceLineRasterizationProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: {
+ transform_fromhost_VkPipelineRasterizationLineStateCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationLineStateCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: {
+ transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfo(
+ resourceTracker, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfo*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceIndexTypeUint8Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceMaintenance5Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceMaintenance5Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance5Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: {
+ transform_fromhost_VkPipelineCreateFlags2CreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCreateFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: {
+ transform_fromhost_VkBufferUsageFlags2CreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkBufferUsageFlags2CreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: {
+ transform_fromhost_VkPhysicalDevicePushDescriptorProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePushDescriptorProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: {
+ transform_fromhost_VkRenderingAttachmentLocationInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderingAttachmentLocationInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: {
+ transform_fromhost_VkRenderingInputAttachmentIndexInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderingInputAttachmentIndexInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceMaintenance6Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Features*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceMaintenance6Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance6Properties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: {
+ transform_fromhost_VkBindMemoryStatus(
+ resourceTracker, reinterpret_cast<VkBindMemoryStatus*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
+ transform_fromhost_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeatures*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
+ transform_fromhost_VkPhysicalDevicePipelineRobustnessFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: {
+ transform_fromhost_VkPhysicalDevicePipelineRobustnessProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineRobustnessProperties*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: {
+ transform_fromhost_VkPipelineRobustnessCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRobustnessCreateInfo*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceHostImageCopyFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyFeatures*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceHostImageCopyProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceHostImageCopyProperties*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: {
+ transform_fromhost_VkSubresourceHostMemcpySize(
+ resourceTracker,
+ reinterpret_cast<VkSubresourceHostMemcpySize*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: {
+ transform_fromhost_VkHostImageCopyDevicePerformanceQuery(
+ resourceTracker,
+ reinterpret_cast<VkHostImageCopyDevicePerformanceQuery*>(structExtension_out));
break;
}
#endif
@@ -9823,60 +10583,6 @@
break;
}
#endif
-#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
- transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
- resourceTracker,
- reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
- transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
- transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
- transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR(
- resourceTracker,
- reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
- transform_fromhost_VkBufferUsageFlags2CreateInfoKHR(
- resourceTracker,
- reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
- break;
- }
-#endif
-#ifdef VK_KHR_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: {
- transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: {
- transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(
- structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: {
- transform_fromhost_VkPipelineRasterizationLineStateCreateInfoKHR(
- resourceTracker, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(
- structExtension_out));
- break;
- }
-#endif
#ifdef VK_ANDROID_native_buffer
case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
transform_fromhost_VkNativeBufferANDROID(
@@ -9979,6 +10685,12 @@
structExtension_out));
break;
}
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
+ break;
+ }
#endif
#ifdef VK_EXT_provoking_vertex
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
@@ -10009,32 +10721,6 @@
break;
}
#endif
-#ifdef VK_EXT_host_image_copy
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
- transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
- transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- resourceTracker,
- reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
- transform_fromhost_VkSubresourceHostMemcpySizeEXT(
- resourceTracker,
- reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
- break;
- }
- case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
- transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT(
- resourceTracker,
- reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
- break;
- }
-#endif
#ifdef VK_EXT_texel_buffer_alignment
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
diff --git a/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.h b/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.h
index 0fb5072..9ea9ddc 100644
--- a/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/src/gfxstream/guest/vulkan_enc/goldfish_vk_transform_guest.h
@@ -1758,6 +1758,318 @@
ResourceTracker* resourceTracker, VkDeviceImageMemoryRequirements* toTransform);
#endif
+#ifdef VK_VERSION_1_4
+void transform_tohost_VkPhysicalDeviceVulkan14Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceVulkan14Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceVulkan14Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Properties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceVulkan14Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan14Properties* toTransform);
+
+void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfo(
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfo* toTransform);
+
+void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfo(
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeatures* toTransform);
+
+void transform_tohost_VkQueueFamilyGlobalPriorityProperties(
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityProperties* toTransform);
+
+void transform_fromhost_VkQueueFamilyGlobalPriorityProperties(
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityProperties* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSubgroupRotateFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSubgroupRotateFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderFloatControls2Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloatControls2Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderFloatControls2Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloatControls2Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderExpectAssumeFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderExpectAssumeFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderExpectAssumeFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceLineRasterizationFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceLineRasterizationFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceLineRasterizationProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceLineRasterizationProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationProperties* toTransform);
+
+void transform_tohost_VkPipelineRasterizationLineStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineRasterizationLineStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDeviceVertexAttributeDivisorProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorProperties(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDeviceVertexAttributeDivisorProperties* toTransform);
+
+void transform_tohost_VkVertexInputBindingDivisorDescription(
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescription* toTransform);
+
+void transform_fromhost_VkVertexInputBindingDivisorDescription(
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescription* toTransform);
+
+void transform_tohost_VkPipelineVertexInputDivisorStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVertexAttributeDivisorFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVertexAttributeDivisorFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceIndexTypeUint8Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceIndexTypeUint8Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8Features* toTransform);
+
+void transform_tohost_VkMemoryMapInfo(ResourceTracker* resourceTracker,
+ VkMemoryMapInfo* toTransform);
+
+void transform_fromhost_VkMemoryMapInfo(ResourceTracker* resourceTracker,
+ VkMemoryMapInfo* toTransform);
+
+void transform_tohost_VkMemoryUnmapInfo(ResourceTracker* resourceTracker,
+ VkMemoryUnmapInfo* toTransform);
+
+void transform_fromhost_VkMemoryUnmapInfo(ResourceTracker* resourceTracker,
+ VkMemoryUnmapInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance5Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance5Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Properties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5Properties* toTransform);
+
+void transform_tohost_VkRenderingAreaInfo(ResourceTracker* resourceTracker,
+ VkRenderingAreaInfo* toTransform);
+
+void transform_fromhost_VkRenderingAreaInfo(ResourceTracker* resourceTracker,
+ VkRenderingAreaInfo* toTransform);
+
+void transform_tohost_VkImageSubresource2(ResourceTracker* resourceTracker,
+ VkImageSubresource2* toTransform);
+
+void transform_fromhost_VkImageSubresource2(ResourceTracker* resourceTracker,
+ VkImageSubresource2* toTransform);
+
+void transform_tohost_VkDeviceImageSubresourceInfo(ResourceTracker* resourceTracker,
+ VkDeviceImageSubresourceInfo* toTransform);
+
+void transform_fromhost_VkDeviceImageSubresourceInfo(ResourceTracker* resourceTracker,
+ VkDeviceImageSubresourceInfo* toTransform);
+
+void transform_tohost_VkSubresourceLayout2(ResourceTracker* resourceTracker,
+ VkSubresourceLayout2* toTransform);
+
+void transform_fromhost_VkSubresourceLayout2(ResourceTracker* resourceTracker,
+ VkSubresourceLayout2* toTransform);
+
+void transform_tohost_VkPipelineCreateFlags2CreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineCreateFlags2CreateInfo(
+ ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfo* toTransform);
+
+void transform_tohost_VkBufferUsageFlags2CreateInfo(ResourceTracker* resourceTracker,
+ VkBufferUsageFlags2CreateInfo* toTransform);
+
+void transform_fromhost_VkBufferUsageFlags2CreateInfo(ResourceTracker* resourceTracker,
+ VkBufferUsageFlags2CreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDevicePushDescriptorProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePushDescriptorProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorProperties* toTransform);
+
+void transform_tohost_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+ ResourceTracker* resourceTracker,
+ VkPhysicalDeviceDynamicRenderingLocalReadFeatures* toTransform);
+
+void transform_tohost_VkRenderingAttachmentLocationInfo(
+ ResourceTracker* resourceTracker, VkRenderingAttachmentLocationInfo* toTransform);
+
+void transform_fromhost_VkRenderingAttachmentLocationInfo(
+ ResourceTracker* resourceTracker, VkRenderingAttachmentLocationInfo* toTransform);
+
+void transform_tohost_VkRenderingInputAttachmentIndexInfo(
+ ResourceTracker* resourceTracker, VkRenderingInputAttachmentIndexInfo* toTransform);
+
+void transform_fromhost_VkRenderingInputAttachmentIndexInfo(
+ ResourceTracker* resourceTracker, VkRenderingInputAttachmentIndexInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance6Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance6Features(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance6Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Properties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance6Properties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance6Properties* toTransform);
+
+void transform_tohost_VkBindMemoryStatus(ResourceTracker* resourceTracker,
+ VkBindMemoryStatus* toTransform);
+
+void transform_fromhost_VkBindMemoryStatus(ResourceTracker* resourceTracker,
+ VkBindMemoryStatus* toTransform);
+
+void transform_tohost_VkBindDescriptorSetsInfo(ResourceTracker* resourceTracker,
+ VkBindDescriptorSetsInfo* toTransform);
+
+void transform_fromhost_VkBindDescriptorSetsInfo(ResourceTracker* resourceTracker,
+ VkBindDescriptorSetsInfo* toTransform);
+
+void transform_tohost_VkPushConstantsInfo(ResourceTracker* resourceTracker,
+ VkPushConstantsInfo* toTransform);
+
+void transform_fromhost_VkPushConstantsInfo(ResourceTracker* resourceTracker,
+ VkPushConstantsInfo* toTransform);
+
+void transform_tohost_VkPushDescriptorSetInfo(ResourceTracker* resourceTracker,
+ VkPushDescriptorSetInfo* toTransform);
+
+void transform_fromhost_VkPushDescriptorSetInfo(ResourceTracker* resourceTracker,
+ VkPushDescriptorSetInfo* toTransform);
+
+void transform_tohost_VkPushDescriptorSetWithTemplateInfo(
+ ResourceTracker* resourceTracker, VkPushDescriptorSetWithTemplateInfo* toTransform);
+
+void transform_fromhost_VkPushDescriptorSetWithTemplateInfo(
+ ResourceTracker* resourceTracker, VkPushDescriptorSetWithTemplateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineProtectedAccessFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineProtectedAccessFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineProtectedAccessFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDevicePipelineRobustnessFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDevicePipelineRobustnessProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDevicePipelineRobustnessProperties* toTransform);
+
+void transform_tohost_VkPipelineRobustnessCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineRobustnessCreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineRobustnessCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineRobustnessCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceHostImageCopyFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyFeatures(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceHostImageCopyProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyProperties(
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyProperties* toTransform);
+
+void transform_tohost_VkMemoryToImageCopy(ResourceTracker* resourceTracker,
+ VkMemoryToImageCopy* toTransform);
+
+void transform_fromhost_VkMemoryToImageCopy(ResourceTracker* resourceTracker,
+ VkMemoryToImageCopy* toTransform);
+
+void transform_tohost_VkImageToMemoryCopy(ResourceTracker* resourceTracker,
+ VkImageToMemoryCopy* toTransform);
+
+void transform_fromhost_VkImageToMemoryCopy(ResourceTracker* resourceTracker,
+ VkImageToMemoryCopy* toTransform);
+
+void transform_tohost_VkCopyMemoryToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyMemoryToImageInfo* toTransform);
+
+void transform_fromhost_VkCopyMemoryToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyMemoryToImageInfo* toTransform);
+
+void transform_tohost_VkCopyImageToMemoryInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToMemoryInfo* toTransform);
+
+void transform_fromhost_VkCopyImageToMemoryInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToMemoryInfo* toTransform);
+
+void transform_tohost_VkCopyImageToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToImageInfo* toTransform);
+
+void transform_fromhost_VkCopyImageToImageInfo(ResourceTracker* resourceTracker,
+ VkCopyImageToImageInfo* toTransform);
+
+void transform_tohost_VkHostImageLayoutTransitionInfo(ResourceTracker* resourceTracker,
+ VkHostImageLayoutTransitionInfo* toTransform);
+
+void transform_fromhost_VkHostImageLayoutTransitionInfo(
+ ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfo* toTransform);
+
+void transform_tohost_VkSubresourceHostMemcpySize(ResourceTracker* resourceTracker,
+ VkSubresourceHostMemcpySize* toTransform);
+
+void transform_fromhost_VkSubresourceHostMemcpySize(ResourceTracker* resourceTracker,
+ VkSubresourceHostMemcpySize* toTransform);
+
+void transform_tohost_VkHostImageCopyDevicePerformanceQuery(
+ ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQuery* toTransform);
+
+void transform_fromhost_VkHostImageCopyDevicePerformanceQuery(
+ ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQuery* toTransform);
+
+#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderingInfo, transform_tohost_VkRenderingInfoKHR)
@@ -1787,36 +2099,6 @@
DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCommandBufferInheritanceRenderingInfo,
transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR)
-void transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker, VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform);
-
-void transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker, VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform);
-
-void transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
-
-void transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
-
-void transform_tohost_VkAttachmentSampleCountInfoAMD(ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform);
-
-void transform_fromhost_VkAttachmentSampleCountInfoAMD(ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform);
-
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentSampleCountInfoAMD,
- transform_tohost_VkAttachmentSampleCountInfoNV)
-
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentSampleCountInfoAMD,
- transform_fromhost_VkAttachmentSampleCountInfoNV)
-
-void transform_tohost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform);
-
-void transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform);
-
#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceFeatures2,
@@ -2428,18 +2710,6 @@
DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSynchronization2Features,
transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR)
-void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform);
-
-void transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform);
-
-void transform_tohost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform);
-
-void transform_fromhost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform);
-
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
@@ -2535,73 +2805,71 @@
#endif
#ifdef VK_KHR_maintenance5
-void transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMaintenance5Features,
+ transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMaintenance5Features,
+ transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR)
-void transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMaintenance5Properties,
+ transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMaintenance5Properties,
+ transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR)
-void transform_tohost_VkRenderingAreaInfoKHR(ResourceTracker* resourceTracker,
- VkRenderingAreaInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderingAreaInfo, transform_tohost_VkRenderingAreaInfoKHR)
-void transform_fromhost_VkRenderingAreaInfoKHR(ResourceTracker* resourceTracker,
- VkRenderingAreaInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderingAreaInfo,
+ transform_fromhost_VkRenderingAreaInfoKHR)
-void transform_tohost_VkImageSubresource2KHR(ResourceTracker* resourceTracker,
- VkImageSubresource2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceImageSubresourceInfo,
+ transform_tohost_VkDeviceImageSubresourceInfoKHR)
-void transform_fromhost_VkImageSubresource2KHR(ResourceTracker* resourceTracker,
- VkImageSubresource2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceImageSubresourceInfo,
+ transform_fromhost_VkDeviceImageSubresourceInfoKHR)
-void transform_tohost_VkDeviceImageSubresourceInfoKHR(ResourceTracker* resourceTracker,
- VkDeviceImageSubresourceInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageSubresource2, transform_tohost_VkImageSubresource2KHR)
-void transform_fromhost_VkDeviceImageSubresourceInfoKHR(
- ResourceTracker* resourceTracker, VkDeviceImageSubresourceInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageSubresource2,
+ transform_fromhost_VkImageSubresource2KHR)
-void transform_tohost_VkSubresourceLayout2KHR(ResourceTracker* resourceTracker,
- VkSubresourceLayout2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubresourceLayout2,
+ transform_tohost_VkSubresourceLayout2KHR)
-void transform_fromhost_VkSubresourceLayout2KHR(ResourceTracker* resourceTracker,
- VkSubresourceLayout2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubresourceLayout2,
+ transform_fromhost_VkSubresourceLayout2KHR)
-void transform_tohost_VkPipelineCreateFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineCreateFlags2CreateInfo,
+ transform_tohost_VkPipelineCreateFlags2CreateInfoKHR)
-void transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineCreateFlags2CreateInfo,
+ transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR)
-void transform_tohost_VkBufferUsageFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferUsageFlags2CreateInfo,
+ transform_tohost_VkBufferUsageFlags2CreateInfoKHR)
-void transform_fromhost_VkBufferUsageFlags2CreateInfoKHR(
- ResourceTracker* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferUsageFlags2CreateInfo,
+ transform_fromhost_VkBufferUsageFlags2CreateInfoKHR)
#endif
#ifdef VK_KHR_line_rasterization
-void transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceLineRasterizationFeatures,
+ transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceLineRasterizationFeatures,
+ transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesKHR)
-void transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceLineRasterizationProperties,
+ transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesKHR(
- ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceLineRasterizationProperties,
+ transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesKHR)
-void transform_tohost_VkPipelineRasterizationLineStateCreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineRasterizationLineStateCreateInfo,
+ transform_tohost_VkPipelineRasterizationLineStateCreateInfoKHR)
-void transform_fromhost_VkPipelineRasterizationLineStateCreateInfoKHR(
- ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineRasterizationLineStateCreateInfo,
+ transform_fromhost_VkPipelineRasterizationLineStateCreateInfoKHR)
#endif
#ifdef VK_ANDROID_native_buffer
@@ -2759,22 +3027,22 @@
ResourceTracker* resourceTracker,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkVertexInputBindingDivisorDescription,
transform_tohost_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkVertexInputBindingDivisorDescriptionKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkVertexInputBindingDivisorDescription,
transform_fromhost_VkVertexInputBindingDivisorDescriptionEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineVertexInputDivisorStateCreateInfo,
transform_tohost_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfo,
transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeatures,
transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeatures,
transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
#endif
@@ -2811,6 +3079,12 @@
void transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
ResourceTracker* resourceTracker, VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
+void transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
+
+void transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
+
#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures,
@@ -2871,30 +3145,30 @@
#endif
#ifdef VK_EXT_line_rasterization
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceLineRasterizationFeatures,
transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceLineRasterizationFeatures,
transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceLineRasterizationProperties,
transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceLineRasterizationProperties,
transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineRasterizationLineStateCreateInfo,
transform_tohost_VkPipelineRasterizationLineStateCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineRasterizationLineStateCreateInfoKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineRasterizationLineStateCreateInfo,
transform_fromhost_VkPipelineRasterizationLineStateCreateInfoEXT)
#endif
#ifdef VK_EXT_index_type_uint8
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceIndexTypeUint8Features,
transform_tohost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceIndexTypeUint8FeaturesKHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceIndexTypeUint8Features,
transform_fromhost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
#endif
@@ -2907,76 +3181,73 @@
#endif
#ifdef VK_EXT_host_image_copy
-void transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceHostImageCopyFeatures,
+ transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceHostImageCopyFeatures,
+ transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT)
-void transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceHostImageCopyProperties,
+ transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
- ResourceTracker* resourceTracker, VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceHostImageCopyProperties,
+ transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT)
-void transform_tohost_VkMemoryToImageCopyEXT(ResourceTracker* resourceTracker,
- VkMemoryToImageCopyEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryToImageCopy, transform_tohost_VkMemoryToImageCopyEXT)
-void transform_fromhost_VkMemoryToImageCopyEXT(ResourceTracker* resourceTracker,
- VkMemoryToImageCopyEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryToImageCopy,
+ transform_fromhost_VkMemoryToImageCopyEXT)
-void transform_tohost_VkImageToMemoryCopyEXT(ResourceTracker* resourceTracker,
- VkImageToMemoryCopyEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageToMemoryCopy, transform_tohost_VkImageToMemoryCopyEXT)
-void transform_fromhost_VkImageToMemoryCopyEXT(ResourceTracker* resourceTracker,
- VkImageToMemoryCopyEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageToMemoryCopy,
+ transform_fromhost_VkImageToMemoryCopyEXT)
-void transform_tohost_VkCopyMemoryToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyMemoryToImageInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyMemoryToImageInfo,
+ transform_tohost_VkCopyMemoryToImageInfoEXT)
-void transform_fromhost_VkCopyMemoryToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyMemoryToImageInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyMemoryToImageInfo,
+ transform_fromhost_VkCopyMemoryToImageInfoEXT)
-void transform_tohost_VkCopyImageToMemoryInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToMemoryInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyImageToMemoryInfo,
+ transform_tohost_VkCopyImageToMemoryInfoEXT)
-void transform_fromhost_VkCopyImageToMemoryInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToMemoryInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyImageToMemoryInfo,
+ transform_fromhost_VkCopyImageToMemoryInfoEXT)
-void transform_tohost_VkCopyImageToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToImageInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyImageToImageInfo,
+ transform_tohost_VkCopyImageToImageInfoEXT)
-void transform_fromhost_VkCopyImageToImageInfoEXT(ResourceTracker* resourceTracker,
- VkCopyImageToImageInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyImageToImageInfo,
+ transform_fromhost_VkCopyImageToImageInfoEXT)
-void transform_tohost_VkHostImageLayoutTransitionInfoEXT(
- ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkHostImageLayoutTransitionInfo,
+ transform_tohost_VkHostImageLayoutTransitionInfoEXT)
-void transform_fromhost_VkHostImageLayoutTransitionInfoEXT(
- ResourceTracker* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkHostImageLayoutTransitionInfo,
+ transform_fromhost_VkHostImageLayoutTransitionInfoEXT)
-void transform_tohost_VkSubresourceHostMemcpySizeEXT(ResourceTracker* resourceTracker,
- VkSubresourceHostMemcpySizeEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubresourceHostMemcpySize,
+ transform_tohost_VkSubresourceHostMemcpySizeEXT)
-void transform_fromhost_VkSubresourceHostMemcpySizeEXT(ResourceTracker* resourceTracker,
- VkSubresourceHostMemcpySizeEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubresourceHostMemcpySize,
+ transform_fromhost_VkSubresourceHostMemcpySizeEXT)
-void transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT(
- ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkHostImageCopyDevicePerformanceQuery,
+ transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT)
-void transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT(
- ResourceTracker* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkHostImageCopyDevicePerformanceQuery,
+ transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubresourceLayout2KHR,
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubresourceLayout2,
transform_tohost_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubresourceLayout2KHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubresourceLayout2,
transform_fromhost_VkSubresourceLayout2EXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageSubresource2KHR,
- transform_tohost_VkImageSubresource2EXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageSubresource2, transform_tohost_VkImageSubresource2EXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageSubresource2KHR,
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageSubresource2,
transform_fromhost_VkImageSubresource2EXT)
#endif
